#55

backend/spec/services/post_bulk_creator_spec.rb

@@ -4,6 +4,7 @@ RSpec.describe PostBulkCreator do
   include_context 'English locale'
 
   it 'limits workers to two and keeps failures in their request slots' do
+    locale = Locale.nipponese
     actor = instance_double(User, id: 123)
     allow(User).to receive(:find).with(123) {
       instance_double(User, id: 123)
@@ -65,4 +66,26 @@ RSpec.describe PostBulkCreator do
     expect(results[2].dig(:post, :id)).to eq(3)
     expect(results[3].dig(:post, :id)).to eq(4)
   end
+
+  it 'passes a future English locale to preflight and creation in every worker' do
+    pending '日本語以外の Locale 有効化は別課題で実装する'
+    locale
+    actor = instance_double(User, id: 123)
+    allow(User).to receive(:find).with(123).and_return(actor)
+    preflight = instance_double(PostCreatePreflight)
+    creator = instance_double(PostCreator)
+    post = instance_double(Post, id: 1)
+    allow(PostCreatePreflight).to receive(:new).and_return(preflight)
+    allow(preflight).to receive(:run).with(locale).and_return(existing_post_id: nil)
+    allow(PostCreator).to receive(:new).and_return(creator)
+    allow(creator).to receive(:create!).with(locale).and_return(post)
+
+    results = described_class.new(
+        actor:, posts: [{ title: 'future post' }], thumbnails: { }).run(locale)
+
+    expect(results.fetch(:results)).to contain_exactly(
+        hash_including(status: 'created', post: { id: 1 }))
+    expect(preflight).to have_received(:run).with(locale).once
+    expect(creator).to have_received(:create!).with(locale).once
+  end
 end

backend/spec/services/post_create_plan_spec.rb

@@ -14,6 +14,8 @@ RSpec.describe PostCreatePlan do
     include_context 'English 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)
@@ -39,6 +41,8 @@ RSpec.describe PostCreatePlan do
     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')

backend/spec/services/post_creator_spec.rb

@@ -81,6 +81,8 @@ RSpec.describe PostCreator do
 
     [false, true].each do |planned|
       it "passes locale to tag creation with planned attributes: #{ planned }" do
+        pending '日本語以外の Locale 有効化は別課題で実装する'
+        locale
         attributes = {
             title: 'Locale propagation',
             url: 'https://example.com/locale-post',

backend/spec/services/tag_version_recorder_spec.rb

@@ -1,45 +1,96 @@
 require 'rails_helper'
 
 RSpec.describe TagVersionRecorder do
-  let(:user) { create_member_user! }
-  let!(:tag) { create(:tag, primary_name: '日本語名') }
   include_context 'English locale'
 
+  let(:user) { create_member_user! }
+  let!(:tag) { create(:tag, primary_name: '日本語名') }
+
   before do
-    create(:tag_name, :alias, tag:, name: '別名')
+    create(:tag_name, :alias, tag:, name: 'alias_z')
+    create(:tag_name, :alias, tag:, name: 'alias_a')
+  end
+
+  def nipponese_snapshot
+    { 'name' => '日本語名', 'script_code' => 'Jpan', 'auto_generated' => false,
+      'aliases' => [{ 'name' => 'alias_a', 'script_code' => 'Jpan' },
+                    { 'name' => 'alias_z', 'script_code' => 'Jpan' }] }
+  end
+
+  def prepare_english_names!
+    locale
     primary_tag_name_for(tag, 'en').update!(name: 'English name', auto_generated: false)
     create(:tag_name, :alias, tag:, language_code: 'en', script_code: 'Latn',
                               name: 'English alias')
   end
 
-  it 'snapshots every language primary name and alias deterministically' do
+  it 'snapshots the Nipponese primary and sorted aliases in grouped names' do
     version = described_class.record!(tag:, event_type: :create, created_by_user: user)
 
-    expect(version.names).to eq([
-      { 'language_code' => 'en', 'name' => 'English name', 'script_code' => 'Latn',
-        'primary_flg' => true, 'auto_generated' => false },
-      { 'language_code' => 'en', 'name' => 'English alias', 'script_code' => 'Latn',
-        'primary_flg' => false, 'auto_generated' => false },
-      { 'language_code' => 'ja', 'name' => '日本語名', 'script_code' => 'Jpan',
-        'primary_flg' => true, 'auto_generated' => false },
-      { 'language_code' => 'ja', 'name' => '別名', 'script_code' => 'Jpan',
-        'primary_flg' => false, 'auto_generated' => false }
-    ])
+    expect(version.reload.names).to eq('ja' => nipponese_snapshot)
   end
 
-  it 'creates a version for an English-only name change and preserves prior names' do
+  it 'does not create a version for an unchanged Nipponese snapshot' do
     original = described_class.record!(tag:, event_type: :create, created_by_user: user)
-    TagName.find_by!(tag:, language_code: 'en', primary_flg: true).update!(name: 'Renamed')
+
+    unchanged = described_class.record!(tag:, event_type: :update, created_by_user: user)
+
+    expect(unchanged.version_no).to eq(original.version_no)
+    expect(tag.reload.tag_versions.count).to eq(1)
+  end
+
+  it 'snapshots an unconfirmed system primary with auto_generated true' do
+    primary_tag_name_for(tag, 'ja').update!(auto_generated: true)
+
+    version = described_class.record!(tag:, event_type: :create, created_by_user: user)
+
+    expect(version.names.fetch('ja')).to eq(nipponese_snapshot.merge('auto_generated' => true))
+  end
+
+  it 'keeps a past snapshot after current primary and alias changes' do
+    original = described_class.record!(tag:, event_type: :create, created_by_user: user)
+    primary_tag_name_for(tag, 'ja').update!(name: '改名後')
+    tag.tag_names.find_by!(name: 'alias_z').destroy!
+
+    updated = described_class.record!(tag:, event_type: :update, created_by_user: user)
+
+    expect(original.reload.names).to eq('ja' => nipponese_snapshot)
+    expect(updated.names.fetch('ja')).to include('name' => '改名後')
+    expect(updated.names.fetch('ja').fetch('aliases'))
+        .to eq([{ 'name' => 'alias_a', 'script_code' => 'Jpan' }])
+    expect(updated.version_no).to eq(2)
+  end
+
+  it 'snapshots future languages together without a request locale argument' do
+    pending '日本語以外の Locale 有効化は別課題で実装する'
+    prepare_english_names!
+
+    version = described_class.record!(tag:, event_type: :create, created_by_user: user)
+
+    expect(version.names).to eq(
+        'ja' => nipponese_snapshot,
+        'en' => { 'name' => 'English name', 'script_code' => 'Latn',
+                  'auto_generated' => false,
+                  'aliases' => [{ 'name' => 'English alias', 'script_code' => 'Latn' }] })
+  end
+
+  it 'creates a version for an English-only change and preserves prior names' do
+    pending '日本語以外の Locale 有効化は別課題で実装する'
+    prepare_english_names!
+    original = described_class.record!(tag:, event_type: :create, created_by_user: user)
+    primary_tag_name_for(tag, 'en').update!(name: 'Renamed')
 
     updated = described_class.record!(tag:, event_type: :update, created_by_user: user)
 
     expect(updated.version_no).to eq(2)
-    expect(original.reload.names).to include(
-      hash_including('language_code' => 'en', 'name' => 'English name'))
-    expect(updated.names).to include(hash_including('language_code' => 'en', 'name' => 'Renamed'))
+    expect(original.reload.names.fetch('en')).to include('name' => 'English name')
+    expect(updated.names.fetch('en')).to include('name' => 'Renamed')
+    expect(updated.names.fetch('ja')).to eq(nipponese_snapshot)
   end
 
   it 'does not create a version for an unchanged multilingual snapshot' do
+    pending '日本語以外の Locale 有効化は別課題で実装する'
+    prepare_english_names!
     described_class.record!(tag:, event_type: :create, created_by_user: user)
 
     unchanged = described_class.record!(tag:, event_type: :update, created_by_user: user)