btrc-hub/backend/spec/models/locale_spec.rb

require 'rails_helper'

RSpec.describe Locale, type: :model do
  include_context 'English locale'

  def create_english_locale!
    prepare_english_reference!
    described_class.create!(code: 'en', language_code: 'en',
                            script_code: 'Latn', region_code: 826,
                            variants: '', name: 'English')
  end

  it 'keeps the active Nipponese locale consistent with its identity tuple' do
    expect(described_class.where(deprecated_at: nil).pluck(:code)).to eq(['ja'])
    expect(described_class.nipponese).to have_attributes(
        code: 'ja', language_code: 'ja', script_code: 'Jpan',
        region_code: 392, variants: '')
  end

  it 'rejects a duplicate locale identity tuple at the database boundary' do
    expect {
      described_class.insert_all!([{ code: 'ja-duplicate', language_code: 'ja',
                                    script_code: 'Jpan', region_code: 392,
                                    variants: '', name: '日本語',
                                    created_at: Time.current }])
    }.to raise_error(ActiveRecord::RecordNotUnique)
  end

  it 'generates a primary name for every existing tag using the name generator' do
    pending '日本語以外の Locale 有効化は別課題で実装する'
    first = create(:tag, primary_name: 'first_existing_tag')
    second = create(:tag, primary_name: 'second_existing_tag')
    allow(TagName).to receive(:generate_name).and_call_original
    allow(TagName).to receive(:generate_name)
        .with(kind_of(described_class), first, primary_tag_name_for(first, 'ja'))
        .and_return('name_from_generator')

    locale = create_english_locale!

    expect(TagName).to have_received(:generate_name)
        .with(locale, first, primary_tag_name_for(first, 'ja'))
    expect(TagName).to have_received(:generate_name)
        .with(locale, second, primary_tag_name_for(second, 'ja'))
    expect(first.tag_names.find_by!(language_code: 'en', primary_flg: true))
        .to have_attributes(name: 'name_from_generator', tag_id: first.id,
                            language_code: 'en', script_code: 'Latn',
                            primary_flg: true, auto_generated: true)
    expect(second.tag_names.find_by!(language_code: 'en', primary_flg: true))
        .to have_attributes(tag_id: second.id, language_code: 'en',
                            script_code: 'Latn', primary_flg: true,
                            auto_generated: true)
    expect(TagName.where(language_code: 'en', primary_flg: true,
                         tag_id: [first.id, second.id]).count).to eq(2)
  end

  it 'does not duplicate an existing primary name in the new language' do
    pending '日本語以外の Locale 有効化は別課題で実装する'
    prepare_english_reference!
    tag = create(:tag, primary_name: 'already_named')
    existing = create(:tag_name, name: 'existing_english', tag:,
                                 language_code: 'en', script_code: 'Latn')

    create_english_locale!

    expect(TagName.where(tag_id: tag.id, language_code: 'en', primary_flg: true))
        .to contain_exactly(existing)
    expect(existing.reload).to have_attributes(
        tag_id: tag.id, language_code: 'en', script_code: 'Latn',
        primary_flg: true, auto_generated: false)
  end

  it 'creates a primary name when the language has only an alias' do
    pending '日本語以外の Locale 有効化は別課題で実装する'
    prepare_english_reference!
    tag = create(:tag, primary_name: 'alias_only_tag')
    alias_name = create(:tag_name, :alias, name: 'alias_en',
                                          tag:,
                                          language_code: 'en', script_code: 'Latn')

    create_english_locale!

    expect(alias_name.reload).to have_attributes(
        tag_id: tag.id,
        language_code: 'en', script_code: 'Latn', primary_flg: false)
    generated = TagName.find_by!(tag_id: tag.id, language_code: 'en', primary_flg: true)
    expect(generated).to have_attributes(tag_id: tag.id, language_code: 'en',
                                         script_code: 'Latn', primary_flg: true,
                                         auto_generated: true)
    expect(TagName.where(tag_id: tag.id, language_code: 'en', primary_flg: true).count).to eq(1)
  end

  it 'rolls back the locale and all generated names when backfill fails' do
    pending '日本語以外の Locale 有効化は別課題で実装する'
    prepare_english_reference!
    first = create(:tag, primary_name: 'atomic_first')
    second = create(:tag, primary_name: 'atomic_second')
    allow(TagName).to receive(:generate_name).and_call_original
    allow(TagName).to receive(:generate_name)
        .with(kind_of(described_class), second, primary_tag_name_for(second, 'ja'))
        .and_raise('backfill failed')

    expect { create_english_locale! }.to raise_error('backfill failed')

    expect(described_class.exists?(code: 'en')).to be(false)
    expect(TagName.where(language_code: 'en', tag_id: [first.id, second.id])).to be_empty
  end

  it 'accepts a stable locale code outside the historical enum values' do
    pending '日本語以外の Locale 有効化は別課題で実装する'
    prepare_english_reference!

    locale = described_class.create!(
        code: 'en-x-rspec', language_code: 'en',
        script_code: 'Latn', region_code: 826,
        variants: 'x-rspec', name: 'English')

    expect(locale.reload).to have_attributes(
        code: 'en-x-rspec', language_code: 'en', script_code: 'Latn',
        region_code: 826, variants: 'x-rspec')
  end

  it 'registers the future British English locale tuple' do
    pending '日本語以外の Locale 有効化は別課題で実装する'

    expect(locale).to have_attributes(code: 'en', language_code: 'en',
                                    script_code: 'Latn', region_code: 826,
                                    variants: '')
  end
end