#55

backend/spec/requests/gekanator_learning_spec.rb

@@ -898,12 +898,11 @@ RSpec.describe 'Gekanator learning API', type: :request do
 
   describe 'GET /gekanator/questions' do
     it 'omits questions for deprecated tags' do
-      active_tag = Tag.create!(name: 'active_question_tag', category: :general)
-      deprecated_tag = Tag.create!(
-        name: 'deprecated_question_tag',
-        category: :general,
-        deprecated_at: Time.current
-      )
+      active_tag = create(:tag, name: 'active_question_tag', category: :general)
+      deprecated_tag = create(:tag,
+          name: 'deprecated_question_tag',
+          category: :general,
+          deprecated_at: Time.current)
 
       [active_tag, deprecated_tag].each do |question_tag|
         GekanatorQuestion.create!(

backend/spec/requests/gekanator_posts_spec.rb

@@ -4,12 +4,11 @@ require 'rails_helper'
 RSpec.describe 'Gekanator posts API', type: :request do
   describe 'GET /gekanator/posts' do
     it 'omits deprecated tags and returns the stored similarity cosine' do
-      active_tag = Tag.create!(name: 'active tag', category: :general)
-      deprecated_tag = Tag.create!(
-        name: 'deprecated tag',
-        category: :general,
-        deprecated_at: Time.current
-      )
+      active_tag = create(:tag, name: 'active tag', category: :general)
+      deprecated_tag = create(:tag,
+          name: 'deprecated tag',
+          category: :general,
+          deprecated_at: Time.current)
       post_record = Post.create!(title: 'source', url: 'https://example.com/source')
       target_post = Post.create!(title: 'target', url: 'https://example.com/target')
 

backend/spec/requests/locale_write_paths_spec.rb

@@ -0,0 +1,232 @@
+require 'rails_helper'
+
+RSpec.describe 'Locale propagation on write paths', type: :request do
+  include_context 'English locale'
+
+  let(:member) { create(:user, :member) }
+
+  before do
+    sign_in_as(member)
+  end
+
+  def expect_localised_tag(name, expected_locale)
+    tag_name = TagName.find_by!(name:, language_code: expected_locale.language_code)
+    expect(tag_name).to have_attributes(
+        script_code: expected_locale.script_code, primary_flg: true)
+    expect(tag_name.tag_id).to be_present
+    expect(tag_name.tag.tag_name_id).to eq(tag_name.id)
+    tag_name.tag
+  end
+
+  ['en', nil].each do |requested_locale|
+    context "with locale #{ requested_locale.inspect }" do
+      let(:locale_params) { requested_locale ? { locale: requested_locale } : { } }
+      let(:expected_locale) { requested_locale ? locale : Locale.nipponese }
+
+      it 'creates post tags in the requested language or Japanese fallback' do
+        post '/posts', params: locale_params.merge(
+            title: 'Locale post', url: 'https://example.com/locale-post',
+            tags: 'locale_post_tag', parent_post_ids: '')
+
+        expect(response).to have_http_status(:created), response.body
+        tag = expect_localised_tag('locale_post_tag', expected_locale)
+        expect(Post.find(json.fetch('id')).tags).to include(tag)
+      end
+
+      it 'updates post tags in the requested language or Japanese fallback' do
+        record = create(:post)
+        PostVersionRecorder.record!(post: record, event_type: :create, created_by_user: member)
+
+        put "/posts/#{ record.id }", params: locale_params.merge(
+            title: record.title, tags: 'locale_updated_tag', parent_post_ids: '',
+            base_version_no: record.reload.version_no)
+
+        expect(response).to have_http_status(:ok), response.body
+        tag = expect_localised_tag('locale_updated_tag', expected_locale)
+        expect(record.reload.tags).to include(tag)
+      end
+
+      it 'passes the resolved locale to bulk creation' do
+        # Worker propagation is exercised in post_bulk_creator_spec.
+        expect_any_instance_of(PostBulkCreator).to receive(:run)
+            .with(expected_locale).and_return(results: [])
+        manifest = [{ title: 'Bulk locale', url: 'https://example.com/bulk-locale',
+                      tags: 'bulk_locale_tag', parent_post_ids: '' }]
+
+        post '/posts/bulk', params: locale_params.merge(posts: JSON.generate(manifest)),
+                            headers: { 'CONTENT_TYPE' => 'multipart/form-data' }
+
+        expect(response).to have_http_status(:ok), response.body
+      end
+
+      it 'creates materials with tags in the resolved locale' do
+        post '/materials', params: locale_params.merge(
+            tag: 'locale_material', url: 'https://example.com/material')
+
+        expect(response).to have_http_status(:created), response.body
+        tag = expect_localised_tag('locale_material', expected_locale)
+        expect(Material.find(json.fetch('id')).tag).to eq(tag)
+      end
+
+      it 'updates materials with tags in the resolved locale' do
+        tag = create(:tag, category: :material)
+        material = Material.create!(tag:, url: 'https://example.com/material')
+
+        put "/materials/#{ material.id }", params: locale_params.merge(
+            tag: 'locale_material_updated', url: material.url)
+
+        expect(response).to have_http_status(:ok), response.body
+        resolved_tag = expect_localised_tag('locale_material_updated', expected_locale)
+        expect(material.reload.tag).to eq(resolved_tag)
+      end
+
+      it 'links Nico external tags to internal tags in the resolved locale' do
+        external = create(:external_tag)
+        NicoTagVersionRecorder.record!(
+            external_tag: external, event_type: :create, created_by_user: member)
+
+        put "/tags/nico/#{ external.id }", params: locale_params.merge(tags: 'locale_link')
+
+        expect(response).to have_http_status(:ok), response.body
+        tag = expect_localised_tag('locale_link', expected_locale)
+        expect(external.reload.linked_tags).to contain_exactly(tag)
+      end
+
+      it 'creates parent tags in the resolved locale' do
+        tag = create(:tag)
+
+        put "/tags/#{ tag.id }", params: locale_params.merge(
+            name: tag.name, category: tag.category, deprecated: false,
+            aliases: '', parent_tags: 'locale_parent')
+
+        expect(response).to have_http_status(:ok), response.body
+        parent = expect_localised_tag('locale_parent', expected_locale)
+        expect(TagImplication.where(tag:).pluck(:parent_tag_id)).to eq([parent.id])
+      end
+    end
+  end
+
+  context 'with existing names in both languages' do
+    let!(:english_name) do
+      create(:tag_name, name: 'shared_name', language_code: 'en', script_code: 'Latn')
+    end
+    let!(:english_tag) { create(:tag, tag_name: english_name, category: :material) }
+    let!(:japanese_tag) do
+      create(:tag, name: 'temporary_japanese', category: :general).tap do |tag|
+        # Isolate lookup from the separately tested uniqueness validation.
+        tag.tag_name.update_columns(name: 'shared_name')
+      end
+    end
+
+    it 'plans and creates the post using the English identity and category' do
+      post '/posts', params: {
+          locale: 'en', title: 'English identity',
+          url: 'https://example.com/english-identity', tags: 'shared_name', parent_post_ids: '' }
+
+      expect(response).to have_http_status(:created), response.body
+      record = Post.find(json.fetch('id'))
+      expect(record.tags).to include(english_tag)
+      expect(record.tags).not_to include(japanese_tag)
+      expect(english_tag.reload.category).to eq('material')
+      expect(japanese_tag.reload.category).to eq('general')
+    end
+
+    it 'updates the post using the English identity' do
+      record = create(:post)
+      PostVersionRecorder.record!(post: record, event_type: :create, created_by_user: member)
+
+      put "/posts/#{ record.id }", params: {
+          locale: 'en', title: record.title, tags: 'shared_name', parent_post_ids: '',
+          base_version_no: record.reload.version_no }
+
+      expect(response).to have_http_status(:ok), response.body
+      expect(record.reload.tags).to include(english_tag)
+      expect(record.tags).not_to include(japanese_tag)
+    end
+
+    it 'resolves the English material tag' do
+      post '/materials', params: {
+          locale: 'en', tag: 'shared_name', url: 'https://example.com/english-material' }
+
+      expect(response).to have_http_status(:created), response.body
+      expect(Material.find(json.fetch('id')).tag).to eq(english_tag)
+      expect(Material.where(tag: japanese_tag)).to be_empty
+    end
+
+    it 'resolves the English parent tag' do
+      child = create(:tag)
+
+      put "/tags/#{ child.id }", params: {
+          locale: 'en', name: child.name, category: child.category, deprecated: false,
+          aliases: '', parent_tags: 'shared_name' }
+
+      expect(response).to have_http_status(:ok), response.body
+      expect(TagImplication.where(tag: child).pluck(:parent_tag_id)).to eq([english_tag.id])
+    end
+
+    it 'resolves the English internal tag for a Nico link' do
+      external = create(:external_tag)
+      NicoTagVersionRecorder.record!(
+          external_tag: external, event_type: :create, created_by_user: member)
+
+      put "/tags/nico/#{ external.id }", params: { locale: 'en', tags: 'shared_name' }
+
+      expect(response).to have_http_status(:ok), response.body
+      expect(external.reload.linked_tags).to contain_exactly(english_tag)
+    end
+  end
+
+  context 'when renaming or updating aliases in English' do
+    let!(:english_name) do
+      create(:tag_name, name: 'english_original', language_code: 'en', script_code: 'Latn')
+    end
+    let!(:tag) { create(:tag, tag_name: english_name) }
+
+    it 'allows a rename to a name already used in Japanese' do
+      japanese = create(:tag, name: 'rename_target')
+
+      patch "/tags/#{ tag.id }", params: { locale: 'en', name: 'rename_target' }
+
+      expect(response).to have_http_status(:ok), response.body
+      expect(tag.reload.tag_name).to have_attributes(
+          name: 'rename_target', language_code: 'en', tag_id: tag.id)
+      expect(japanese.reload.tag_name).to have_attributes(
+          name: 'rename_target', language_code: 'ja', tag_id: japanese.id)
+    end
+
+    it 'creates aliases in the requested language' do
+      put "/tags/#{ tag.id }", params: {
+          locale: 'en', name: tag.name, category: tag.category, deprecated: false,
+          aliases: 'english_alias', parent_tags: '' }
+
+      expect(response).to have_http_status(:ok), response.body
+      expect(TagName.find_by!(language_code: 'en', name: 'english_alias'))
+          .to have_attributes(
+              script_code: 'Latn', canonical_id: english_name.id,
+              tag_id: tag.id, primary_flg: false, language_code: 'en')
+      expect(tag.reload.tag_name_id).to eq(english_name.id)
+    end
+
+    it 'does not take an alias from another language' do
+      japanese = create(:tag, name: 'japanese_owner')
+      japanese_alias = create(:tag_name, :alias, name: 'shared_alias',
+                                                canonical: japanese.tag_name)
+      expect(japanese_alias.reload).to have_attributes(
+          canonical_id: japanese.tag_name_id, tag_id: japanese.id,
+          primary_flg: false, language_code: 'ja')
+
+      put "/tags/#{ tag.id }", params: {
+          locale: 'en', name: tag.name, category: tag.category, deprecated: false,
+          aliases: 'shared_alias', parent_tags: '' }
+
+      expect(response).to have_http_status(:ok), response.body
+      expect(japanese_alias.reload).to have_attributes(
+          canonical_id: japanese.tag_name_id, tag_id: japanese.id,
+          primary_flg: false, language_code: 'ja')
+      expect(TagName.find_by!(language_code: 'en', name: 'shared_alias'))
+          .to have_attributes(
+              canonical_id: english_name.id, tag_id: tag.id,
+              primary_flg: false, language_code: 'en')
+    end
+  end
+end

backend/spec/requests/materials_spec.rb

@@ -26,10 +26,10 @@ RSpec.describe 'Materials API', type: :request do
 
   describe 'GET /materials' do
     let!(:tag_a) do
-      Tag.create!(tag_name: TagName.create!(name: 'material_index_a'), category: :material)
+      create(:tag, name: 'material_index_a', category: :material)
     end
     let!(:tag_b) do
-      Tag.create!(tag_name: TagName.create!(name: 'material_index_b'), category: :material)
+      create(:tag, name: 'material_index_b', category: :material)
     end
 
     let!(:material_a) do
@@ -116,20 +116,20 @@ RSpec.describe 'Materials API', type: :request do
 
     it 'filters by descendant tags and returns stable parent tag groups' do
       root =
-          Tag.create!(tag_name: TagName.create!(name: 'material_scope_root'),
+          create(:tag, name: 'material_scope_root',
                       category: :material)
       child_b =
-          Tag.create!(tag_name: TagName.create!(name: 'material_scope_b'),
+          create(:tag, name: 'material_scope_b',
                       category: :material)
       child_a =
-          Tag.create!(tag_name: TagName.create!(name: 'material_scope_a'),
+          create(:tag, name: 'material_scope_a',
                       category: :material)
       deprecated =
-          Tag.create!(tag_name: TagName.create!(name: 'material_scope_old'),
+          create(:tag, name: 'material_scope_old',
                       category: :material,
                       deprecated_at: Time.current)
       grandchild =
-          Tag.create!(tag_name: TagName.create!(name: 'material_scope_grandchild'),
+          create(:tag, name: 'material_scope_grandchild',
                       category: :material)
       root_material =
           build_material(tag: root, user: member_user,
@@ -179,7 +179,7 @@ RSpec.describe 'Materials API', type: :request do
 
   describe 'GET /materials/:id' do
     let!(:tag) do
-      Tag.create!(tag_name: TagName.create!(name: 'material_show'), category: :material)
+      create(:tag, name: 'material_show', category: :material)
     end
     let!(:material) do
       build_material(tag:, user: member_user, file: dummy_upload(filename: 'show.png'))
@@ -323,8 +323,8 @@ RSpec.describe 'Materials API', type: :request do
       end
 
       it 'returns 422 when the existing tag is not material/character' do
-        general_tag_name = TagName.create!(name: 'material_create_general_tag')
-        Tag.create!(tag_name: general_tag_name, category: :general)
+        general_tag_name = create(:tag_name, name: 'material_create_general_tag')
+        create(:tag, tag_name: general_tag_name, category: :general)
 
         post '/materials', params: {
           tag: 'material_create_general_tag',
@@ -384,7 +384,7 @@ RSpec.describe 'Materials API', type: :request do
 
   describe 'PUT /materials/:id' do
     let!(:tag) do
-      Tag.create!(tag_name: TagName.create!(name: 'material_update_old'), category: :material)
+      create(:tag, name: 'material_update_old', category: :material)
     end
     let!(:material) do
       build_material(tag:, user: member_user, file: dummy_upload(filename: 'old.png'))
@@ -508,7 +508,7 @@ RSpec.describe 'Materials API', type: :request do
 
       it 'backfills a create tag_version for an existing material tag without history' do
         existing_tag =
-            Tag.create!(tag_name: TagName.create!(name: 'material_update_existing_no_history'),
+            create(:tag, name: 'material_update_existing_no_history',
                         category: :material)
 
         expect(existing_tag.tag_versions).to be_empty
@@ -531,7 +531,7 @@ RSpec.describe 'Materials API', type: :request do
 
       it 'backfills a create tag_version for an existing character tag without history' do
         existing_tag =
-            Tag.create!(tag_name: TagName.create!(name: 'material_update_character_no_history'),
+            create(:tag, name: 'material_update_character_no_history',
                         category: :character)
 
         expect(existing_tag.tag_versions).to be_empty
@@ -651,8 +651,8 @@ RSpec.describe 'Materials API', type: :request do
   end
 
   describe 'GET /materials/download.zip' do
-    let!(:tag_a) { Tag.create!(tag_name: TagName.create!(name: 'zip_a'), category: :material) }
-    let!(:tag_b) { Tag.create!(tag_name: TagName.create!(name: 'zip_b'), category: :material) }
+    let!(:tag_a) { create(:tag, name: 'zip_a', category: :material) }
+    let!(:tag_b) { create(:tag, name: 'zip_b', category: :material) }
     let!(:material_a) do
       build_material(tag: tag_a, user: member_user,
                      file: dummy_upload(filename: 'a.png', body: 'zip-a'))
@@ -701,7 +701,7 @@ RSpec.describe 'Materials API', type: :request do
 
   describe 'GET /materials/versions' do
     let!(:tag) do
-      Tag.create!(tag_name: TagName.create!(name: 'material_history'), category: :material)
+      create(:tag, name: 'material_history', category: :material)
     end
     let!(:material) do
       build_material(tag:, user: member_user, file: dummy_upload(filename: 'history.png'))
@@ -776,7 +776,7 @@ RSpec.describe 'Materials API', type: :request do
 
   describe 'DELETE /materials/:id' do
     let!(:tag) do
-      Tag.create!(tag_name: TagName.create!(name: 'material_destroy'), category: :material)
+      create(:tag, name: 'material_destroy', category: :material)
     end
     let!(:material) do
       build_material(tag:, user: member_user, file: dummy_upload(filename: 'destroy.png'))

backend/spec/requests/nico_tags_spec.rb

@@ -162,11 +162,11 @@ RSpec.describe 'NicoTags', type: :request do
 
       nico_tag = create(:external_tag, name: 'nico_tags_spec_source')
 
-      linked_a_name = TagName.create!(name: 'nico_linked_a')
-      linked_a = Tag.create!(tag_name: linked_a_name, category: :general)
+      linked_a_name = create(:tag_name, name: 'nico_linked_a')
+      linked_a = create(:tag, tag_name: linked_a_name, category: :general)
 
-      linked_b_name = TagName.create!(name: 'nico_linked_b')
-      linked_b = Tag.create!(tag_name: linked_b_name, category: :general)
+      linked_b_name = create(:tag_name, name: 'nico_linked_b')
+      linked_b = create(:tag, tag_name: linked_b_name, category: :general)
 
       NicoTagVersionRecorder.record!(external_tag: nico_tag,
                                      event_type: :create, created_by_user: admin)

backend/spec/requests/posts_spec.rb

@@ -113,8 +113,8 @@ RSpec.describe 'Posts API', type: :request do
         'sections' => [])
   end
 
-  let!(:tag_name) { TagName.create!(name: 'spec_tag') }
-  let!(:tag)      { Tag.create!(tag_name: tag_name, category: :general) }
+  let!(:tag_name) { create(:tag_name, name: 'spec_tag') }
+  let!(:tag)      { create(:tag, tag_name: tag_name, category: :general) }
 
   let!(:post_record) do
     Post.create!(title: 'spec post', url: 'https://example.com/spec').tap do |p|
@@ -125,11 +125,11 @@ RSpec.describe 'Posts API', type: :request do
   describe 'GET /posts' do
     let!(:user) { create_member_user! }
 
-    let!(:tag_name) { TagName.create!(name: 'spec_tag') }
-    let!(:tag) { Tag.create!(tag_name:, category: :general) }
-    let!(:tag_name2) { TagName.create!(name: 'unko') }
-    let!(:tag2) { Tag.create!(tag_name: tag_name2, category: :deerjikist) }
-    let!(:alias_tag_name) { TagName.create!(name: 'manko', canonical: tag_name) }
+    let!(:tag_name) { create(:tag_name, name: 'spec_tag') }
+    let!(:tag) { create(:tag, tag_name:, category: :general) }
+    let!(:tag_name2) { create(:tag_name, name: 'unko') }
+    let!(:tag2) { create(:tag, tag_name: tag_name2, category: :deerjikist) }
+    let!(:alias_tag_name) { create(:tag_name, :alias, name: 'manko', canonical: tag_name) }
 
     let!(:hit_post) do
       Post.create!(uploaded_user: user, title: 'hello spec world',
@@ -341,17 +341,17 @@ RSpec.describe 'Posts API', type: :request do
     end
 
     context 'when tags contain not:' do
-      let!(:foo_tag_name) { TagName.create!(name: 'not_spec_foo') }
-      let!(:foo_tag) { Tag.create!(tag_name: foo_tag_name, category: :general) }
+      let!(:foo_tag_name) { create(:tag_name, name: 'not_spec_foo') }
+      let!(:foo_tag) { create(:tag, tag_name: foo_tag_name, category: :general) }
 
-      let!(:bar_tag_name) { TagName.create!(name: 'not_spec_bar') }
-      let!(:bar_tag) { Tag.create!(tag_name: bar_tag_name, category: :general) }
+      let!(:bar_tag_name) { create(:tag_name, name: 'not_spec_bar') }
+      let!(:bar_tag) { create(:tag, tag_name: bar_tag_name, category: :general) }
 
-      let!(:baz_tag_name) { TagName.create!(name: 'not_spec_baz') }
-      let!(:baz_tag) { Tag.create!(tag_name: baz_tag_name, category: :general) }
+      let!(:baz_tag_name) { create(:tag_name, name: 'not_spec_baz') }
+      let!(:baz_tag) { create(:tag, tag_name: baz_tag_name, category: :general) }
 
       let!(:foo_alias_tag_name) do
-        TagName.create!(name: 'not_spec_foo_alias', canonical: foo_tag_name)
+        create(:tag_name, :alias, name: 'not_spec_foo_alias', canonical: foo_tag_name)
       end
 
       let!(:foo_only_post) do
@@ -772,11 +772,10 @@ RSpec.describe 'Posts API', type: :request do
       end
 
       it 'omits deprecated tags' do
-        deprecated_tag = Tag.create!(
-          name: 'deprecated_post_tag',
-          category: :general,
-          deprecated_at: Time.current
-        )
+        deprecated_tag = create(:tag,
+            name: 'deprecated_post_tag',
+            category: :general,
+            deprecated_at: Time.current)
         PostTag.create!(post: post_record, tag: deprecated_tag)
 
         request
@@ -853,9 +852,9 @@ RSpec.describe 'Posts API', type: :request do
 
         tags =
             15.times.map do |i|
-              tag_name = TagName.create!(name: "show_query_tag_#{ i }")
-              tag = Tag.create!(tag_name:, category: :general)
-              TagName.create!(name: "show_query_alias_#{ i }", canonical: tag_name)
+              tag_name = create(:tag_name, name: "show_query_tag_#{ i }")
+              tag = create(:tag, tag_name:, category: :general)
+              create(:tag_name, :alias, name: "show_query_alias_#{ i }", canonical: tag_name)
               PostTag.create!(post: post_record, tag:)
               tag
             end
@@ -1000,7 +999,7 @@ RSpec.describe 'Posts API', type: :request do
 
   describe 'POST /posts' do
     let(:member) { create(:user, :member) }
-    let!(:alias_tag_name) { TagName.create!(name: 'manko', canonical: tag_name) }
+    let!(:alias_tag_name) { create(:tag_name, :alias, name: 'manko', canonical: tag_name) }
 
     it '401 when not logged in' do
       sign_out
@@ -1157,11 +1156,10 @@ RSpec.describe 'Posts API', type: :request do
     end
 
     it 'rejects a deprecated tag specified directly' do
-      Tag.create!(
-        name: 'deprecated_direct_tag',
-        category: :general,
-        deprecated_at: Time.current
-      )
+      create(:tag,
+          name: 'deprecated_direct_tag',
+          category: :general,
+          deprecated_at: Time.current)
       sign_in_as(member)
 
       post '/posts', params: post_write_params(
@@ -1178,18 +1176,16 @@ RSpec.describe 'Posts API', type: :request do
     end
 
     it 'expands through multiple deprecated parent tags and saves active ancestors' do
-      child = Tag.create!(name: 'active_child', category: :general)
-      deprecated_parent = Tag.create!(
-        name: 'deprecated_parent',
-        category: :general,
-        deprecated_at: Time.current
-      )
-      deprecated_grandparent = Tag.create!(
-        name: 'deprecated_grandparent',
-        category: :general,
-        deprecated_at: Time.current
-      )
-      active_grandparent = Tag.create!(name: 'active_grandparent', category: :general)
+      child = create(:tag, name: 'active_child', category: :general)
+      deprecated_parent = create(:tag,
+          name: 'deprecated_parent',
+          category: :general,
+          deprecated_at: Time.current)
+      deprecated_grandparent = create(:tag,
+          name: 'deprecated_grandparent',
+          category: :general,
+          deprecated_at: Time.current)
+      active_grandparent = create(:tag, name: 'active_grandparent', category: :general)
       TagImplication.create!(tag: child, parent_tag: deprecated_parent)
       TagImplication.create!(tag: deprecated_parent, parent_tag: deprecated_grandparent)
       TagImplication.create!(tag: deprecated_grandparent, parent_tag: active_grandparent)
@@ -1622,6 +1618,7 @@ RSpec.describe 'Posts API', type: :request do
         expect(arguments[:thumbnails].keys).to eq([0])
         expect(arguments[:host]).to eq('http://www.example.com')
       end
+      expect(creator).to have_received(:run).with(Locale.nipponese)
     end
 
     it 'rejects malformed manifests as a request-level error' do
@@ -1658,8 +1655,8 @@ RSpec.describe 'Posts API', type: :request do
       create(:post_tag_section, post: post_record, tag:,
                                 begin_ms: 1000, end_ms: 2000)
 
-      tn2 = TagName.create!(name: 'spec_tag_2')
-      replacement_tag = Tag.create!(tag_name: tn2, category: :general)
+      tn2 = create(:tag_name, name: 'spec_tag_2')
+      replacement_tag = create(:tag, tag_name: tn2, category: :general)
 
       put "/posts/#{post_record.id}", params: post_update_params(
           post_record,
@@ -1707,11 +1704,10 @@ RSpec.describe 'Posts API', type: :request do
     end
 
     it 'rejects a deprecated tag specified directly' do
-      Tag.create!(
-        name: 'deprecated_update_tag',
-        category: :general,
-        deprecated_at: Time.current
-      )
+      create(:tag,
+          name: 'deprecated_update_tag',
+          category: :general,
+          deprecated_at: Time.current)
       sign_in_as(member)
 
       put "/posts/#{ post_record.id }", params: post_update_params(
@@ -1986,7 +1982,8 @@ RSpec.describe 'Posts API', type: :request do
 
         base_version = create_post_version_for!(post_record.reload)
 
-        current_tag = Tag.find_or_create_by_tag_name!('current_added_tag', category: :general)
+        current_tag = Tag.find_or_create_by_tag_name!(
+            Locale.nipponese, 'current_added_tag', category: :general)
         PostTag.create!(post: post_record, tag: current_tag, created_user: member)
 
         PostVersionRecorder.record!(
@@ -2015,7 +2012,8 @@ RSpec.describe 'Posts API', type: :request do
 
         base_version = create_post_version_for!(post_record.reload)
 
-        current_tag = Tag.find_or_create_by_tag_name!('current_merge_tag', category: :general)
+        current_tag = Tag.find_or_create_by_tag_name!(
+            Locale.nipponese, 'current_merge_tag', category: :general)
         PostTag.create!(post: post_record, tag: current_tag, created_user: member)
 
         PostVersionRecorder.record!(
@@ -2102,7 +2100,8 @@ RSpec.describe 'Posts API', type: :request do
         sign_in_as(member)
 
         nico_tag = create_nico_tag!('nico:relation_source')
-        linked_tag = Tag.find_or_create_by_tag_name!('relation_linked_tag', category: :general)
+        linked_tag = Tag.find_or_create_by_tag_name!(
+            Locale.nipponese, 'relation_linked_tag', category: :general)
 
         NicoTagRelation.create!(nico_tag:, tag: linked_tag)
         PostExternalTag.create!(post: post_record, external_tag: nico_tag)
@@ -2191,8 +2190,8 @@ RSpec.describe 'Posts API', type: :request do
     let(:oc_from) { Time.zone.local(2019, 12, 31, 0, 0, 0) }
     let(:oc_before) { Time.zone.local(2020, 1, 1, 0, 0, 0) }
 
-    let!(:tag_name2) { TagName.create!(name: 'spec_tag_2') }
-    let!(:tag2) { Tag.create!(tag_name: tag_name2, category: :general) }
+    let!(:tag_name2) { create(:tag_name, name: 'spec_tag_2') }
+    let!(:tag2) { create(:tag, tag_name: tag_name2, category: :general) }
 
     def snapshot_tags(post)
       post.snapshot_tag_names.join(' ')
@@ -2550,8 +2549,8 @@ RSpec.describe 'Posts API', type: :request do
       sign_in_as(member)
       base_version = create_post_version_for!(post_record)
 
-      tag_name2 = TagName.create!(name: 'spec_tag_2')
-      Tag.create!(tag_name: tag_name2, category: :general)
+      tag_name2 = create(:tag_name, name: 'spec_tag_2')
+      create(:tag, tag_name: tag_name2, category: :general)
 
       expect do
         put "/posts/#{post_record.id}", params: post_write_params(
@@ -2715,8 +2714,8 @@ RSpec.describe 'Posts API', type: :request do
 
       base_version = create_post_version_for!(post_record.reload)
 
-      tag_name2 = TagName.create!(name: 'spec_tag_2')
-      tag2 = Tag.create!(tag_name: tag_name2, category: :general)
+      tag_name2 = create(:tag_name, name: 'spec_tag_2')
+      tag2 = create(:tag, tag_name: tag_name2, category: :general)
 
       expect {
         put "/posts/#{post_record.id}", params: post_write_params(

backend/spec/requests/tag_versions_spec.rb

@@ -232,8 +232,8 @@ RSpec.describe 'TagVersions API', type: :request do
     end
 
     it 'does not create tag versions by wiki updates when tag has no versions yet' do
-      wiki_tag_name = TagName.create!(name: 'tag_versions_from_wiki')
-      wiki_tag = Tag.create!(tag_name: wiki_tag_name, category: :general)
+      wiki_tag_name = create(:tag_name, name: 'tag_versions_from_wiki')
+      wiki_tag = create(:tag, tag_name: wiki_tag_name, category: :general)
 
       wiki_page =
           Wiki::Commit.create_content!(

backend/spec/requests/tag_wiki_history_integrity_spec.rb

@@ -8,8 +8,8 @@ RSpec.describe 'Tag and wiki history integrity', type: :request do
   end
 
   def create_tag! name:, category: :general
-    tag_name = TagName.create!(name:)
-    Tag.create!(tag_name:, category:)
+    tag_name = create(:tag_name, name:)
+    create(:tag, tag_name:, category:)
   end
 
   def create_wiki_for_tag! tag:, body: 'wiki body', user: member_user

backend/spec/requests/tags_spec.rb

@@ -2,13 +2,13 @@ require 'cgi'
 require 'rails_helper'
 
 RSpec.describe 'Tags API', type: :request do
-  let!(:tn) { TagName.create!(name: 'spec_tag') }
-  let!(:tag) { Tag.create!(tag_name: tn, category: :general) }
-  let!(:alias_tn) { TagName.create!(name: 'unko', canonical: tn) }
+  let!(:tn) { create(:tag_name, name: 'spec_tag') }
+  let!(:tag) { create(:tag, tag_name: tn, category: :general) }
+  let!(:alias_tn) { create(:tag_name, :alias, name: 'unko', canonical: tn) }
   let!(:post) { Post.create!(url: 'https://example.com/unkounkounko') }
   let!(:post_tag) { PostTag.create!(post:, tag:) }
-  let!(:tn2) { TagName.create!(name: 'unknown') }
-  let!(:tag2) { Tag.create!(tag_name: tn2, category: :general) }
+  let!(:tn2) { create(:tag_name, name: 'unknown') }
+  let!(:tag2) { create(:tag, tag_name: tn2, category: :general) }
 
   def response_tags
     json.fetch('tags')
@@ -91,7 +91,7 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'filters tags by category' do
-      meme = Tag.create!(tag_name: TagName.create!(name: 'meme_only'), category: :meme)
+      meme = create(:tag, name: 'meme_only', category: :meme)
 
       get '/tags', params: { category: 'meme' }
 
@@ -101,12 +101,11 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'filters tags by deprecated state' do
-      deprecated_tag = Tag.create!(
-        name: 'deprecated_filter',
-        category: :general,
-        deprecated_at: 1.day.from_now
-      )
-      active_tag = Tag.create!(name: 'active_filter', category: :general)
+      deprecated_tag = create(:tag,
+          name: 'deprecated_filter',
+          category: :general,
+          deprecated_at: 1.day.from_now)
+      active_tag = create(:tag, name: 'active_filter', category: :general)
 
       get '/tags', params: { name: '_filter', deprecated: '1' }
 
@@ -122,9 +121,9 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'filters tags by post_count range' do
-      low = Tag.create!(tag_name: TagName.create!(name: 'pc_low'), category: :general)
-      mid = Tag.create!(tag_name: TagName.create!(name: 'pc_mid'), category: :general)
-      high = Tag.create!(tag_name: TagName.create!(name: 'pc_high'), category: :general)
+      low = create(:tag, name: 'pc_low', category: :general)
+      mid = create(:tag, name: 'pc_mid', category: :general)
+      high = create(:tag, name: 'pc_high', category: :general)
 
       low.update_columns(post_count: 1)
       mid.update_columns(post_count: 3)
@@ -142,8 +141,8 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'filters tags by created_at range' do
-      old_tag = Tag.create!(tag_name: TagName.create!(name: 'created_old'), category: :general)
-      new_tag = Tag.create!(tag_name: TagName.create!(name: 'created_new'), category: :general)
+      old_tag = create(:tag, name: 'created_old', category: :general)
+      new_tag = create(:tag, name: 'created_new', category: :general)
 
       old_time = Time.zone.local(2024, 1, 1, 0, 0, 0)
       new_time = Time.zone.local(2024, 2, 1, 0, 0, 0)
@@ -162,8 +161,8 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'filters tags by updated_at range' do
-      old_tag = Tag.create!(tag_name: TagName.create!(name: 'updated_old'), category: :general)
-      new_tag = Tag.create!(tag_name: TagName.create!(name: 'updated_new'), category: :general)
+      old_tag = create(:tag, name: 'updated_old', category: :general)
+      new_tag = create(:tag, name: 'updated_new', category: :general)
 
       old_time = Time.zone.local(2024, 3, 1, 0, 0, 0)
       new_time = Time.zone.local(2024, 4, 1, 0, 0, 0)
@@ -182,12 +181,12 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'orders tags by custom category order' do
-      Tag.create!(tag_name: TagName.create!(name: 'cat_deerjikist'), category: :deerjikist)
-      Tag.create!(tag_name: TagName.create!(name: 'cat_meme'), category: :meme)
-      Tag.create!(tag_name: TagName.create!(name: 'cat_character'), category: :character)
-      Tag.create!(tag_name: TagName.create!(name: 'cat_general'), category: :general)
-      Tag.create!(tag_name: TagName.create!(name: 'cat_material'), category: :material)
-      Tag.create!(tag_name: TagName.create!(name: 'cat_meta'), category: :meta)
+      create(:tag, name: 'cat_deerjikist', category: :deerjikist)
+      create(:tag, name: 'cat_meme', category: :meme)
+      create(:tag, name: 'cat_character', category: :character)
+      create(:tag, name: 'cat_general', category: :general)
+      create(:tag, name: 'cat_material', category: :material)
+      create(:tag, name: 'cat_meta', category: :meta)
       create(:external_tag, name: 'cat_nico')
 
       get '/tags', params: { name: 'cat_', order: 'category:asc', limit: 20 }
@@ -202,20 +201,20 @@ RSpec.describe 'Tags API', type: :request do
     context 'with mixed legacy pagination' do
       let!(:first_tag) do
         create(:tag,
-               tag_name: create(:tag_name, name: 'a_mixed_page'),
-               category: :meme)
+            tag_name: create(:tag_name, name: 'a_mixed_page'),
+            category: :meme)
       end
 
       let!(:middle_tag) do
         create(:tag,
-               tag_name: create(:tag_name, name: 'm_mixed_page'),
-               category: :meta)
+            tag_name: create(:tag_name, name: 'm_mixed_page'),
+            category: :meta)
       end
 
       let!(:last_tag) do
         create(:tag,
-               tag_name: create(:tag_name, name: 'z_mixed_page'),
-               category: :general)
+            tag_name: create(:tag_name, name: 'z_mixed_page'),
+            category: :general)
       end
 
       let!(:first_external) do
@@ -265,7 +264,7 @@ RSpec.describe 'Tags API', type: :request do
 
     it 'paginates and keeps total count' do
       %w[pag_a pag_b pag_c].each do |name|
-        Tag.create!(tag_name: TagName.create!(name:), category: :general)
+        create(:tag, tag_name: create(:tag_name, name:), category: :general)
       end
 
       get '/tags', params: { name: 'pag_', order: 'name:asc', page: 2, limit: 2 }
@@ -276,8 +275,8 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'falls back to default ordering when order is invalid' do
-      low = Tag.create!(tag_name: TagName.create!(name: 'fallback_low'), category: :general)
-      high = Tag.create!(tag_name: TagName.create!(name: 'fallback_high'), category: :general)
+      low = create(:tag, name: 'fallback_low', category: :general)
+      high = create(:tag, name: 'fallback_high', category: :general)
 
       low.update_columns(post_count: 1)
       high.update_columns(post_count: 9)
@@ -290,7 +289,7 @@ RSpec.describe 'Tags API', type: :request do
 
     it 'normalises invalid page and limit' do
       %w[norm_a norm_b].each do |name|
-        Tag.create!(tag_name: TagName.create!(name:), category: :general)
+        create(:tag, tag_name: create(:tag_name, name:), category: :general)
       end
 
       get '/tags', params: { name: 'norm_', order: 'name:asc', page: 0, limit: 0 }
@@ -302,10 +301,9 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'returns aliases and parent tags' do
-      parent_tag = Tag.create!(
-        tag_name: TagName.create!(name: 'index_parent_tag'),
-        category: :meme
-      )
+      parent_tag = create(:tag,
+          tag_name: create(:tag_name, name: 'index_parent_tag'),
+          category: :meme)
       TagImplication.create!(tag:, parent_tag:)
 
       get '/tags', params: { name: 'spec_tag' }
@@ -349,10 +347,9 @@ RSpec.describe 'Tags API', type: :request do
       end
 
       it 'returns aliases and parent tags' do
-        parent_tag = Tag.create!(
-          tag_name: TagName.create!(name: 'show_parent_tag'),
-          category: :character
-        )
+        parent_tag = create(:tag,
+            tag_name: create(:tag_name, name: 'show_parent_tag'),
+            category: :character)
         TagImplication.create!(tag:, parent_tag:)
 
         request
@@ -416,7 +413,7 @@ RSpec.describe 'Tags API', type: :request do
 
   describe 'GET /tags/autocomplete' do
     it 'combines internal and external matches without conflating equal ids' do
-      internal = Tag.create!(category: :general, name: 'mixed_internal', post_count: 2)
+      internal = create(:tag, category: :general, name: 'mixed_internal', post_count: 2)
       external = create(:external_tag, id: internal.id,
                                        name: 'mixed_external', post_count: 3)
 
@@ -455,7 +452,7 @@ RSpec.describe 'Tags API', type: :request do
     it 'limits the combined results to 20 and sorts ties by displayed name' do
       11.times do |i|
         name = "combined_#{ i.to_s.rjust(2, '0') }"
-        Tag.create!(category: :general, name:, post_count: 1)
+        create(:tag, category: :general, name:, post_count: 1)
         create(:external_tag, name:, post_count: 1)
       end
 
@@ -467,9 +464,9 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'excludes external tags but preserves internal alias matches when nico is false' do
-      internal = Tag.create!(category: :general, name: 'switch_internal', post_count: 1)
-      alias_target = Tag.create!(category: :general, name: 'alias_target', post_count: 1)
-      TagName.create!(name: 'switch_alias', canonical: alias_target.tag_name)
+      internal = create(:tag, category: :general, name: 'switch_internal', post_count: 1)
+      alias_target = create(:tag, category: :general, name: 'alias_target', post_count: 1)
+      create(:tag_name, :alias, name: 'switch_alias', canonical: alias_target.tag_name)
       create(:external_tag, name: 'switch_external', post_count: 1)
 
       get '/tags/autocomplete', params: { q: 'switch', nico: '0' }
@@ -484,11 +481,13 @@ RSpec.describe 'Tags API', type: :request do
     ['%', '_'].each do |wildcard|
       it "treats #{ wildcard } literally for canonical, alias, and external names" do
         literal = "literal#{ wildcard }match"
-        Tag.create!(category: :general, name: literal, post_count: 1)
-        alias_target = Tag.create!(category: :general, name: 'literal_alias_target', post_count: 1)
-        TagName.create!(name: "#{ literal }_alias", canonical: alias_target.tag_name)
+        create(:tag, category: :general, name: literal, post_count: 1)
+        alias_target = create(
+            :tag, category: :general, name: 'literal_alias_target', post_count: 1)
+        create(:tag_name, :alias, name: "#{ literal }_alias",
+                                  canonical: alias_target.tag_name)
         create(:external_tag, name: literal, post_count: 1)
-        Tag.create!(category: :general, name: 'literalXmatch', post_count: 2)
+        create(:tag, category: :general, name: 'literalXmatch', post_count: 2)
         create(:external_tag, name: 'literalXmatch', post_count: 2)
 
         get '/tags/autocomplete', params: { q: "literal#{ wildcard }" }
@@ -523,11 +522,10 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'omits deprecated tags' do
-      deprecated_tag = Tag.create!(
-        name: 'spec_deprecated',
-        category: :general,
-        deprecated_at: Time.current
-      )
+      deprecated_tag = create(:tag,
+          name: 'spec_deprecated',
+          category: :general,
+          deprecated_at: Time.current)
       deprecated_tag.update_columns(post_count: 1)
 
       get '/tags/autocomplete', params: { q: 'spec_', present: '0' }
@@ -820,27 +818,27 @@ RSpec.describe 'Tags API', type: :request do
 
   describe 'GET /tags/with-depth' do
     let!(:root_meme) do
-      Tag.create!(tag_name: TagName.create!(name: 'depth_a_root_meme'), category: :meme)
+      create(:tag, name: 'depth_a_root_meme', category: :meme)
     end
 
     let!(:root_material) do
-      Tag.create!(tag_name: TagName.create!(name: 'depth_b_root_material'), category: :material)
+      create(:tag, name: 'depth_b_root_material', category: :material)
     end
 
     let!(:hidden_general_root) do
-      Tag.create!(tag_name: TagName.create!(name: 'depth_hidden_general_root'), category: :general)
+      create(:tag, name: 'depth_hidden_general_root', category: :general)
     end
 
     let!(:child_character) do
-      Tag.create!(tag_name: TagName.create!(name: 'depth_child_character'), category: :character)
+      create(:tag, name: 'depth_child_character', category: :character)
     end
 
     let!(:grandchild_material) do
-      Tag.create!(tag_name: TagName.create!(name: 'depth_grandchild_material'), category: :material)
+      create(:tag, name: 'depth_grandchild_material', category: :material)
     end
 
     let!(:child_general) do
-      Tag.create!(tag_name: TagName.create!(name: 'depth_child_general'), category: :general)
+      create(:tag, name: 'depth_child_general', category: :general)
     end
 
     before do
@@ -883,15 +881,13 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'passes through deprecated tags when finding children' do
-      deprecated_middle = Tag.create!(
-        name: 'depth_deprecated_middle',
-        category: :character,
-        deprecated_at: Time.current
-      )
-      visible_descendant = Tag.create!(
-        name: 'depth_visible_descendant',
-        category: :material
-      )
+      deprecated_middle = create(:tag,
+          name: 'depth_deprecated_middle',
+          category: :character,
+          deprecated_at: Time.current)
+      visible_descendant = create(:tag,
+          name: 'depth_visible_descendant',
+          category: :material)
       TagImplication.create!(parent_tag: root_material, tag: deprecated_middle)
       TagImplication.create!(parent_tag: deprecated_middle, tag: visible_descendant)
 
@@ -903,24 +899,20 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'passes through multiple deprecated tags for roots and has_children' do
-      active_child = Tag.create!(
-        name: 'depth_active_child_below_deprecated',
-        category: :character
-      )
-      deprecated_parent = Tag.create!(
-        name: 'depth_deprecated_parent',
-        category: :character,
-        deprecated_at: Time.current
-      )
-      deprecated_grandparent = Tag.create!(
-        name: 'depth_deprecated_grandparent',
-        category: :material,
-        deprecated_at: Time.current
-      )
-      active_ancestor = Tag.create!(
-        name: 'depth_active_ancestor',
-        category: :meme
-      )
+      active_child = create(:tag,
+          name: 'depth_active_child_below_deprecated',
+          category: :character)
+      deprecated_parent = create(:tag,
+          name: 'depth_deprecated_parent',
+          category: :character,
+          deprecated_at: Time.current)
+      deprecated_grandparent = create(:tag,
+          name: 'depth_deprecated_grandparent',
+          category: :material,
+          deprecated_at: Time.current)
+      active_ancestor = create(:tag,
+          name: 'depth_active_ancestor',
+          category: :meme)
       TagImplication.create!(tag: active_child, parent_tag: deprecated_parent)
       TagImplication.create!(tag: deprecated_parent, parent_tag: deprecated_grandparent)
       TagImplication.create!(tag: deprecated_grandparent, parent_tag: active_ancestor)
@@ -945,15 +937,13 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'treats an active tag with only deprecated ancestors as a root' do
-      active_child = Tag.create!(
-        name: 'depth_root_below_deprecated',
-        category: :character
-      )
-      deprecated_parent = Tag.create!(
-        name: 'depth_root_deprecated_parent',
-        category: :material,
-        deprecated_at: Time.current
-      )
+      active_child = create(:tag,
+          name: 'depth_root_below_deprecated',
+          category: :character)
+      deprecated_parent = create(:tag,
+          name: 'depth_root_deprecated_parent',
+          category: :material,
+          deprecated_at: Time.current)
       TagImplication.create!(tag: active_child, parent_tag: deprecated_parent)
 
       get '/tags/with-depth'
@@ -967,16 +957,14 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     it 'terminates when deprecated implications contain a cycle' do
-      first = Tag.create!(
-        name: 'depth_cycle_first',
-        category: :character,
-        deprecated_at: Time.current
-      )
-      second = Tag.create!(
-        name: 'depth_cycle_second',
-        category: :material,
-        deprecated_at: Time.current
-      )
+      first = create(:tag,
+          name: 'depth_cycle_first',
+          category: :character,
+          deprecated_at: Time.current)
+      second = create(:tag,
+          name: 'depth_cycle_second',
+          category: :material,
+          deprecated_at: Time.current)
       TagImplication.create!(tag: first, parent_tag: root_material)
       TagImplication.create!(tag: second, parent_tag: first)
       now = Time.current
@@ -1002,19 +990,19 @@ RSpec.describe 'Tags API', type: :request do
     let!(:material_user) { create_member_user! }
 
     let!(:root_tag) do
-      Tag.create!(tag_name: TagName.create!(name: 'materials_root'), category: :material)
+      create(:tag, name: 'materials_root', category: :material)
     end
 
     let!(:child_a_tag) do
-      Tag.create!(tag_name: TagName.create!(name: 'materials_child_a'), category: :material)
+      create(:tag, name: 'materials_child_a', category: :material)
     end
 
     let!(:child_b_tag) do
-      Tag.create!(tag_name: TagName.create!(name: 'materials_child_b'), category: :character)
+      create(:tag, name: 'materials_child_b', category: :character)
     end
 
     let!(:grandchild_tag) do
-      Tag.create!(tag_name: TagName.create!(name: 'materials_grandchild'), category: :material)
+      create(:tag, name: 'materials_grandchild', category: :material)
     end
 
     let!(:root_material) do
@@ -1158,14 +1146,12 @@ RSpec.describe 'Tags API', type: :request do
       end
 
       it 'name, category, aliases, parent tags をまとめて更新できる' do
-        old_parent = Tag.create!(
-          tag_name: TagName.create!(name: 'put_old_parent'),
-          category: :general
-        )
-        kept_parent = Tag.create!(
-          tag_name: TagName.create!(name: 'put_kept_parent'),
-          category: :general
-        )
+        old_parent = create(:tag,
+            tag_name: create(:tag_name, name: 'put_old_parent'),
+            category: :general)
+        kept_parent = create(:tag,
+            tag_name: create(:tag_name, name: 'put_kept_parent'),
+            category: :general)
         TagImplication.create!(tag:, parent_tag: old_parent)
         TagImplication.create!(tag:, parent_tag: kept_parent)
 
@@ -1310,14 +1296,12 @@ RSpec.describe 'Tags API', type: :request do
       end
 
       it 'parent tag の snapshot も作成する' do
-        old_parent = Tag.create!(
-          tag_name: TagName.create!(name: 'put_snapshot_old_parent'),
-          category: :general
-        )
-        new_parent = Tag.create!(
-          tag_name: TagName.create!(name: 'put_snapshot_new_parent'),
-          category: :general
-        )
+        old_parent = create(:tag,
+            tag_name: create(:tag_name, name: 'put_snapshot_old_parent'),
+            category: :general)
+        new_parent = create(:tag,
+            tag_name: create(:tag_name, name: 'put_snapshot_new_parent'),
+            category: :general)
         TagImplication.create!(tag:, parent_tag: old_parent)
 
         put "/tags/#{ tag.id }", params: {
@@ -1454,14 +1438,12 @@ RSpec.describe 'Tags API', type: :request do
       end
 
       it '別名を他 tag から奪った場合、奪はれた側の tag version も作成する' do
-        old_owner = Tag.create!(
-          tag_name: TagName.create!(name: 'put_alias_old_owner'),
-          category: :general
-        )
-        stolen_alias = TagName.create!(
-          name: 'put_stolen_alias',
-          canonical: old_owner.tag_name
-        )
+        old_owner = create(:tag,
+            tag_name: create(:tag_name, name: 'put_alias_old_owner'),
+            category: :general)
+        stolen_alias = create(:tag_name, :alias,
+            name: 'put_stolen_alias',
+            canonical: old_owner.tag_name)
 
         expect(old_owner.tag_name.aliases.map(&:name)).to include('put_stolen_alias')
 
@@ -1492,14 +1474,12 @@ RSpec.describe 'Tags API', type: :request do
       end
 
       it '別 tag の alias 名を rename で奪へる' do
-        old_owner = Tag.create!(
-          tag_name: TagName.create!(name: 'put_alias_collision_owner'),
-          category: :general
-        )
-        stolen_alias = TagName.create!(
-          name: 'put_alias_collision_name',
-          canonical: old_owner.tag_name
-        )
+        old_owner = create(:tag,
+            tag_name: create(:tag_name, name: 'put_alias_collision_owner'),
+            category: :general)
+        stolen_alias = create(:tag_name, :alias,
+            name: 'put_alias_collision_name',
+            canonical: old_owner.tag_name)
         wiki_page =
             Wiki::Commit.create_content!(
                 tag_name: tag.tag_name,
@@ -1515,7 +1495,7 @@ RSpec.describe 'Tags API', type: :request do
           deprecated: '0',
         }
 
-        expect(response).to have_http_status(:ok)
+        expect(response).to have_http_status(:ok), response.body
 
         tag.reload
         old_owner.reload
@@ -1534,10 +1514,9 @@ RSpec.describe 'Tags API', type: :request do
       end
 
       it 'parent_tags に指定すると循環する tag は 422 にする' do
-        child = Tag.create!(
-          tag_name: TagName.create!(name: 'put_cycle_child'),
-          category: :general
-        )
+        child = create(:tag,
+            tag_name: create(:tag_name, name: 'put_cycle_child'),
+            category: :general)
 
         TagImplication.create!(tag: child, parent_tag: tag)
 

backend/spec/requests/wiki_conflict_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe 'Wiki conflict handling', type: :request do
   it 'returns 409 when base_revision_id is stale' do
     page =
         Wiki::Commit.create_content!(
-            tag_name: TagName.create!(name: 'wiki_conflict_request'),
+            tag_name: create(:tag_name, name: 'wiki_conflict_request'),
             body: 'first',
             created_by_user: user,
             message: 'init')

backend/spec/requests/wiki_history_integrity_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe 'Wiki history integrity', type: :request do
 
   def create_wiki_page title:, body: 'body', message: 'init', user: self.user
     Wiki::Commit.create_content!(
-        tag_name: TagName.create!(name: title),
+        tag_name: create(:tag_name, name: title),
         body:,
         created_by_user: user,
         message:)

backend/spec/requests/wiki_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe 'Wiki API', type: :request do
 
   let!(:user) { create_member_user! }
 
-  let!(:tn) { TagName.create!(name: 'spec_wiki_title') }
+  let!(:tn) { create(:tag_name, name: 'spec_wiki_title') }
   let!(:page) do
     Wiki::Commit.create_content!(
         tag_name: tn,
@@ -19,11 +19,10 @@ RSpec.describe 'Wiki API', type: :request do
         message: 'init')
   end
   let!(:tag) do
-    Tag.create!(
-      tag_name: tn,
-      category: :general,
-      deprecated_at: Time.zone.local(2026, 6, 1)
-    )
+    create(:tag,
+        tag_name: tn,
+        category: :general,
+        deprecated_at: Time.zone.local(2026, 6, 1))
   end
 
   describe 'GET /wiki' do
@@ -208,7 +207,7 @@ RSpec.describe 'Wiki API', type: :request do
       { 'X-Transfer-Code' => user.inheritance_code }
     end
 
-    let!(:test_tag_name) { TagName.create!(name: 'TestPage') }
+    let!(:test_tag_name) { create(:tag_name, name: 'TestPage') }
 
     let!(:page) do
       Wiki::Commit.create_content!(
@@ -275,8 +274,8 @@ RSpec.describe 'Wiki API', type: :request do
       end
 
       it 'wiki body だけを変更しても tag version は作成しない' do
-        linked_tag_name = TagName.create!(name: 'wiki_body_only_tag')
-        linked_tag = Tag.create!(tag_name: linked_tag_name, category: :general)
+        linked_tag_name = create(:tag_name, name: 'wiki_body_only_tag')
+        linked_tag = create(:tag, tag_name: linked_tag_name, category: :general)
 
         TagVersionRecorder.record!(
             tag: linked_tag,
@@ -359,13 +358,13 @@ RSpec.describe 'Wiki API', type: :request do
   describe 'GET /wiki/search' do
     before do
       Wiki::Commit.create_content!(
-          tag_name: TagName.create!(name: 'spec_wiki_title_2'),
+          tag_name: create(:tag_name, name: 'spec_wiki_title_2'),
           body: 'search body 2',
           created_by_user: user,
           message: 'init')
 
       Wiki::Commit.create_content!(
-          tag_name: TagName.create!(name: 'unrelated_title'),
+          tag_name: create(:tag_name, name: 'unrelated_title'),
           body: 'unrelated body',
           created_by_user: user,
           message: 'init')
@@ -434,7 +433,7 @@ RSpec.describe 'Wiki API', type: :request do
 
     it 'returns empty array when page has no revisions and filtered by id' do
       # 別ページを作って revision 無し
-      tn2 = TagName.create!(name: 'spec_no_rev')
+      tn2 = create(:tag_name, name: 'spec_no_rev')
       # 異常データ: revision 無し WikiPage を直接作る
       p2 = WikiPage.create!(
           tag_name: tn2,
@@ -514,7 +513,7 @@ RSpec.describe 'Wiki API', type: :request do
 
   describe 'Wiki::Commit.redirect!' do
     it 'raises because redirect revisions are deprecated' do
-      target_tag_name = TagName.create!(name: 'redirect_deprecated_target')
+      target_tag_name = create(:tag_name, name: 'redirect_deprecated_target')
       target =
           Wiki::Commit.create_content!(
               tag_name: target_tag_name,
@@ -535,8 +534,8 @@ RSpec.describe 'Wiki API', type: :request do
   end
 
   it 'wiki title を変更すると対応する tag の version を作成する' do
-    linked_tag_name = TagName.create!(name: 'wiki_linked_tag_for_version')
-    linked_tag = Tag.create!(tag_name: linked_tag_name, category: :general)
+    linked_tag_name = create(:tag_name, name: 'wiki_linked_tag_for_version')
+    linked_tag = create(:tag, tag_name: linked_tag_name, category: :general)
 
     linked_page =
         Wiki::Commit.create_content!(

backend/spec/requests/wiki_title_collision_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe 'Wiki title collision', type: :request do
 
   def create_wiki_page title:, body:
     Wiki::Commit.create_content!(
-        tag_name: TagName.create!(name: title),
+        tag_name: create(:tag_name, name: title),
         body:,
         created_by_user: user,
         message: 'init')