#428

backend/spec/models/locale_spec.rb

@@ -57,6 +57,7 @@ RSpec.describe Locale, type: :model do
     tag = create(:tag, primary_name: 'already_named')
     existing = create(:tag_name, name: 'existing_ainu', tag:,
                                  language_code: 'ain', script_code: 'Kana')
+    versions_before = tag.tag_versions.order(:version_no).map(&:attributes)
 
     create_ainu_locale!
 
@@ -65,6 +66,7 @@ RSpec.describe Locale, type: :model do
     expect(existing.reload).to have_attributes(
         tag_id: tag.id, language_code: 'ain', script_code: 'Kana',
         primary_flg: true, auto_generated: false)
+    expect(tag.tag_versions.order(:version_no).map(&:attributes)).to eq(versions_before)
   end
 
   it 'adds the new language primary while preserving existing names and aliases' do
@@ -88,6 +90,7 @@ RSpec.describe Locale, type: :model do
     prepare_ainu_reference!
     first = create(:tag, primary_name: 'atomic_first')
     second = create(:tag, primary_name: 'atomic_second')
+    versions_before = TagVersion.order(:id).map(&:attributes)
     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'))
@@ -97,6 +100,69 @@ RSpec.describe Locale, type: :model do
 
     expect(described_class.exists?(code: 'ain-Kana')).to be(false)
     expect(TagName.where(language_code: 'ain', tag_id: [first.id, second.id])).to be_empty
+    expect(TagVersion.order(:id).map(&:attributes)).to eq(versions_before)
+  end
+
+  it 'records a separate automatic update for each tag without changing its authored create' do
+    author = create(:user, :admin)
+    tags = ['locale_history_first', 'locale_history_second'].map do |name|
+      Tag.find_or_create_by_tag_name!(Locale.nipponese, name, category: :general,
+                                     created_by_user: author)
+    end
+    originals = tags.map { |tag| tag.tag_versions.sole.attributes }
+
+    expect { create_ainu_locale! }.to change(TagVersion, :count).by(2)
+
+    tags.zip(originals).each do |tag, original|
+      versions = tag.tag_versions.order(:version_no).to_a
+      expect(versions.map(&:event_type)).to eq(['create', 'update'])
+      expect(versions.first.attributes).to eq(original)
+      expect(versions.first.created_by_user_id).to eq(author.id)
+      expect(versions.last).to have_attributes(version_no: 2, created_by_user_id: nil)
+      expect(versions.last.names.fetch('ain')).to eq(
+          'name' => tag.name('ja'), 'script_code' => 'Kana',
+          'auto_generated' => true, 'aliases' => [])
+      expect(versions.first.names.keys).to eq(['ja'])
+      expect(tag.reload.version_no).to eq(2)
+    end
+
+    expect { TagNameCompletion.for_locale!(Locale.find('ain-Kana')) }
+        .not_to change(TagVersion, :count)
+  end
+
+  it 'records automatic before and after snapshots for a tag without any history' do
+    tag = create(:tag, primary_name: 'legacy_before_locale')
+    expect(tag.tag_versions).to be_empty
+
+    create_ainu_locale!
+
+    versions = tag.tag_versions.order(:version_no).to_a
+    expect(versions.map(&:event_type)).to eq(['create', 'update'])
+    expect(versions.map(&:created_by_user_id)).to eq([nil, nil])
+    expect(versions.first.names.keys).to eq(['ja'])
+    expect(versions.last.names.keys).to match_array(['ja', 'ain'])
+    expect(versions.last.names.fetch('ja')).to eq(versions.first.names.fetch('ja'))
+  end
+
+  it 'rolls back earlier tag names and histories when a later history fails' do
+    first = create(:tag, primary_name: 'history_atomic_first')
+    second = create(:tag, primary_name: 'history_atomic_second')
+    names_before = TagName.order(:id).map(&:attributes)
+    versions_before = TagVersion.order(:id).map(&:attributes)
+    allow(TagVersioning).to receive(:record!).and_wrap_original do |original, tag, **options|
+      if tag.id == second.id && options[:event_type] == :update
+        raise ActiveRecord::RecordNotSaved, 'history failed'
+      end
+      original.call(tag, **options)
+    end
+
+    expect { create_ainu_locale! }
+        .to raise_error(ActiveRecord::RecordNotSaved, 'history failed')
+
+    expect(described_class.exists?(code: 'ain-Kana')).to be(false)
+    expect(TagName.order(:id).map(&:attributes)).to eq(names_before)
+    expect(TagVersion.order(:id).map(&:attributes)).to eq(versions_before)
+    expect([first.reload.version_no, second.reload.version_no]).to eq([1, 1])
   end
 
   it 'rejects a private locale code outside the supported locale set' do