#428

backend/spec/services/post_create_plan_spec.rb

@@ -11,23 +11,22 @@ RSpec.describe PostCreatePlan do
   end
 
   context 'with an explicit locale' do
-    include_context 'English locale'
+    include_context 'Ainu locale'
 
     it 'resolves the matching language identity and its parents' do
-      pending '日本語以外の Locale 有効化は別課題で実装する'
       locale
-      english_name = create(:tag_name, name: 'shared_name',
-                                      language_code: 'en', script_code: 'Latn')
-      english = create(:tag, primary_tag_name: english_name, category: :character)
+      ainu_name = create(:tag_name, name: 'shared_name',
+                                      language_code: 'ain', script_code: 'Kana')
+      ainu = create(:tag, primary_tag_name: ainu_name, category: :character)
       nipponese = create(:tag, primary_name: 'temporary_nipponese', category: :general)
       # The DB permits this identity; validation has its own contract spec.
       primary_tag_name_for(nipponese, 'ja').update_columns(name: 'shared_name')
-      english_parent_name = create(:tag_name, name: 'english_parent',
-                                            language_code: 'en', script_code: 'Latn')
-      english_parent = create(:tag, primary_tag_name: english_parent_name,
+      ainu_parent_name = create(:tag_name, name: 'ainu_parent',
+                                            language_code: 'ain', script_code: 'Kana')
+      ainu_parent = create(:tag, primary_tag_name: ainu_parent_name,
                                     category: :material)
       nipponese_parent = create(:tag, primary_name: 'nipponese_parent', category: :general)
-      TagImplication.create!(tag: english, parent_tag: english_parent)
+      TagImplication.create!(tag: ainu, parent_tag: ainu_parent)
       TagImplication.create!(tag: nipponese, parent_tag: nipponese_parent)
 
       plan = described_class.new(attributes: { tags: 'shared_name' }).build!(locale)
@@ -35,35 +34,34 @@ RSpec.describe PostCreatePlan do
       expect(plan[:direct_tag_specs]).to eq(
           [{ name: 'shared_name', category: :character }])
       expect(plan[:post_tag_specs]).to include(
-          { name: primary_tag_name_for(english_parent, 'en').name, category: :material })
+          { name: primary_tag_name_for(ainu_parent, 'ain').name, category: :material })
       expect(plan[:post_tag_specs].pluck(:name))
           .not_to include(primary_tag_name_for(nipponese_parent, 'ja').name)
     end
 
     it 'resolves aliases within the requested language' do
-      pending '日本語以外の Locale 有効化は別課題で実装する'
       locale
       nipponese = create(:tag, primary_name: 'nipponese_canonical')
-      english_name = create(:tag_name, name: 'english_canonical',
-                                      language_code: 'en', script_code: 'Latn')
-      english = create(:tag, primary_tag_name: english_name, category: :character)
+      ainu_name = create(:tag_name, name: 'ainu_canonical',
+                                      language_code: 'ain', script_code: 'Kana')
+      ainu = create(:tag, primary_tag_name: ainu_name, category: :character)
       nipponese_alias = create(:tag_name, :alias, name: 'shared_alias',
                                                   tag: nipponese)
-      english_alias = create(:tag_name, :alias, name: 'shared_alias',
-                                               tag: english,
-                                               language_code: 'en', script_code: 'Latn')
+      ainu_alias = create(:tag_name, :alias, name: 'shared_alias',
+                                               tag: ainu,
+                                               language_code: 'ain', script_code: 'Kana')
 
       expect(nipponese_alias.reload).to have_attributes(
           tag_id: nipponese.id,
           primary_flg: false, language_code: 'ja')
-      expect(english_alias.reload).to have_attributes(
-          tag_id: english.id,
-          primary_flg: false, language_code: 'en')
+      expect(ainu_alias.reload).to have_attributes(
+          tag_id: ainu.id,
+          primary_flg: false, language_code: 'ain')
 
       plan = described_class.new(attributes: { tags: 'shared_alias' }).build!(locale)
 
       expect(plan[:direct_tag_specs]).to eq(
-          [{ name: english_name.name, category: :character }])
+          [{ name: ainu_name.name, category: :character }])
     end
   end