Merge remote-tracking branch 'origin/main' into feature/047

backend/spec/factories/wiki_pages.rb

@@ -3,5 +3,7 @@ FactoryBot.define do
     title { "TestPage" }
     association :created_user, factory: :user
     association :updated_user, factory: :user
+
+    body { ' ' }
   end
 end

backend/spec/models/post_version_spec.rb

@@ -0,0 +1,40 @@
+require 'rails_helper'
+
+RSpec.describe PostVersion, type: :model do
+  let!(:tag_name) { TagName.create!(name: 'post_version_spec_tag') }
+  let!(:tag) { Tag.create!(tag_name: tag_name, category: :general) }
+
+  let!(:post_record) do
+    Post.create!(title: 'spec post', url: 'https://example.com/post-version-spec').tap do |post|
+      PostTag.create!(post: post, tag: tag)
+    end
+  end
+
+  let!(:post_version) do
+    PostVersion.create!(
+      post: post_record,
+      version_no: 1,
+      event_type: 'create',
+      title: post_record.title,
+      url: post_record.url,
+      thumbnail_base: post_record.thumbnail_base,
+      tags: post_record.snapshot_tag_names.join(' '),
+      original_created_from: post_record.original_created_from,
+      original_created_before: post_record.original_created_before,
+      created_at: Time.current,
+      created_by_user: nil
+    )
+  end
+
+  it 'is read only after create' do
+    expect do
+      post_version.update!(title: 'changed')
+    end.to raise_error(ActiveRecord::ReadOnlyRecord)
+  end
+
+  it 'cannot be destroyed' do
+    expect do
+      post_version.destroy!
+    end.to raise_error(ActiveRecord::ReadOnlyRecord)
+  end
+end

backend/spec/models/tag_spec.rb

@@ -107,11 +107,13 @@ RSpec.describe Tag, type: :model do
     context 'when the source tag_name has a wiki_page' do
       let!(:source_post_tag) { PostTag.create!(post: post_record, tag: source_tag) }
       let!(:wiki_page) do
-        WikiPage.create!(
-          tag_name: source_tag_name,
-          created_user: create_admin_user!,
-          updated_user: create_admin_user!
-        )
+        admin = create_admin_user!
+
+        Wiki::Commit.create_content!(
+            tag_name: source_tag_name,
+            body: 'source wiki body',
+            created_by_user: admin,
+            message: 'init')
       end
 
       it 'rolls back the transaction' do
@@ -145,5 +147,69 @@ RSpec.describe Tag, type: :model do
         expect(target_tag.reload.post_count).to eq(0)
       end
     end
+
+    def snapshot_tags(post)
+      post.snapshot_tag_names.join(' ')
+    end
+
+    def create_post_version_for!(post, version_no: 1, event_type: 'create', created_by_user: nil)
+      PostVersion.create!(
+        post: post,
+        version_no: version_no,
+        event_type: event_type,
+        title: post.title,
+        url: post.url,
+        thumbnail_base: post.thumbnail_base,
+        tags: snapshot_tags(post),
+        original_created_from: post.original_created_from,
+        original_created_before: post.original_created_before,
+        created_at: Time.current,
+        created_by_user: created_by_user
+      )
+    end
+
+    context 'when post versions are enabled' do
+      let!(:source_post_tag) { PostTag.create!(post: post_record, tag: source_tag) }
+      let!(:unaffected_post) do
+        Post.create!(url: 'https://example.com/posts/2', title: 'unaffected post')
+      end
+
+      before do
+        create_post_version_for!(post_record)
+        create_post_version_for!(unaffected_post)
+      end
+
+      it 'creates an update post_version only for affected posts' do
+        expect {
+          described_class.merge_tags!(target_tag, [source_tag])
+        }.to change(PostVersion, :count).by(1)
+
+        affected_versions = post_record.reload.post_versions.order(:version_no)
+        expect(affected_versions.pluck(:version_no)).to eq([1, 2])
+
+        latest = affected_versions.last
+        expect(latest.event_type).to eq('update')
+        expect(latest.created_by_user).to be_nil
+        expect(latest.tags).to eq(snapshot_tags(post_record.reload))
+
+        expect(unaffected_post.reload.post_versions.count).to eq(1)
+      end
+    end
+
+    context 'when the source tag has no active post_tags' do
+      let!(:another_post) do
+        Post.create!(url: 'https://example.com/posts/3', title: 'another post')
+      end
+
+      before do
+        create_post_version_for!(another_post)
+      end
+
+      it 'does not create any post_version' do
+        expect {
+          described_class.merge_tags!(target_tag, [source_tag])
+        }.not_to change(PostVersion, :count)
+      end
+    end
   end
 end

backend/spec/models/version_record_spec.rb

@@ -0,0 +1,74 @@
+require 'rails_helper'
+
+RSpec.describe VersionRecord, type: :model do
+  let!(:tag) { create(:tag, name: 'version_record_tag') }
+  let!(:nico_tag) { create(:tag, :nico, name: 'nico:version_record_tag') }
+
+  it 'makes TagVersion read only after create' do
+    version = TagVersion.create!(
+      tag: tag,
+      version_no: 1,
+      event_type: 'create',
+      name: tag.name,
+      category: tag.category,
+      aliases: '',
+      parent_tag_ids: '',
+      created_at: Time.current,
+      created_by_user: nil
+    )
+
+    expect {
+      version.update!(name: 'changed')
+    }.to raise_error(ActiveRecord::ReadOnlyRecord)
+  end
+
+  it 'prevents TagVersion destroy' do
+    version = TagVersion.create!(
+      tag: tag,
+      version_no: 1,
+      event_type: 'create',
+      name: tag.name,
+      category: tag.category,
+      aliases: '',
+      parent_tag_ids: '',
+      created_at: Time.current,
+      created_by_user: nil
+    )
+
+    expect {
+      version.destroy!
+    }.to raise_error(ActiveRecord::ReadOnlyRecord)
+  end
+
+  it 'makes NicoTagVersion read only after create' do
+    version = NicoTagVersion.create!(
+      tag: nico_tag,
+      version_no: 1,
+      event_type: 'create',
+      name: nico_tag.name,
+      linked_tags: '',
+      created_at: Time.current,
+      created_by_user: nil
+    )
+
+    expect {
+      version.update!(name: 'nico:changed')
+    }.to raise_error(ActiveRecord::ReadOnlyRecord)
+  end
+
+  it 'prevents NicoTagVersion destroy' do
+    version = NicoTagVersion.create!(
+      tag: nico_tag,
+      version_no: 1,
+      event_type: 'create',
+      name: nico_tag.name,
+      linked_tags: '',
+      created_at: Time.current,
+      created_by_user: nil
+    )
+
+    expect {
+      version.destroy!
+    }.to raise_error(ActiveRecord::ReadOnlyRecord)
+  end
+end

backend/spec/requests/materials_spec.rb

@@ -0,0 +1,378 @@
+require 'rails_helper'
+
+RSpec.describe 'Materials API', type: :request do
+  let!(:member_user) { create(:user, :member) }
+  let!(:guest_user)  { create(:user) }
+
+  def dummy_upload(filename: 'dummy.png', type: 'image/png', body: 'dummy')
+    Rack::Test::UploadedFile.new(StringIO.new(body), type, original_filename: filename)
+  end
+
+  def response_materials
+    json.fetch('materials')
+  end
+
+  def build_material(tag:, user:, parent: nil, file: dummy_upload, url: nil)
+    Material.new(tag:, parent:, url:, created_by_user: user, updated_by_user: user).tap do |material|
+      material.file.attach(file) if file
+      material.save!
+    end
+  end
+
+  describe 'GET /materials' do
+    let!(:tag_a) { Tag.create!(tag_name: TagName.create!(name: 'material_index_a'), category: :material) }
+    let!(:tag_b) { Tag.create!(tag_name: TagName.create!(name: 'material_index_b'), category: :material) }
+
+    let!(:material_a) do
+      build_material(tag: tag_a, user: member_user, file: dummy_upload(filename: 'a.png'))
+    end
+
+    let!(:material_b) do
+      build_material(tag: tag_b, user: member_user, parent: material_a, file: dummy_upload(filename: 'b.png'))
+    end
+
+    before do
+      old_time = Time.zone.local(2026, 3, 29, 1, 0, 0)
+      new_time = Time.zone.local(2026, 3, 29, 2, 0, 0)
+
+      material_a.update_columns(created_at: old_time, updated_at: old_time)
+      material_b.update_columns(created_at: new_time, updated_at: new_time)
+    end
+
+    it 'returns materials with count and metadata' do
+      get '/materials'
+
+      expect(response).to have_http_status(:ok)
+      expect(json).to include('materials', 'count')
+      expect(response_materials).to be_an(Array)
+      expect(json['count']).to eq(2)
+
+      row = response_materials.find { |m| m['id'] == material_b.id }
+      expect(row).to be_present
+      expect(row['tag']).to include(
+        'id' => tag_b.id,
+        'name' => 'material_index_b',
+        'category' => 'material'
+      )
+      expect(row['created_by_user']).to include(
+        'id' => member_user.id,
+        'name' => member_user.name
+      )
+      expect(row['content_type']).to eq('image/png')
+    end
+
+    it 'filters materials by tag_id' do
+      get '/materials', params: { tag_id: material_a.tag_id }
+
+      expect(response).to have_http_status(:ok)
+      expect(json['count']).to eq(1)
+      expect(response_materials.map { |m| m['id'] }).to eq([material_a.id])
+    end
+
+    it 'filters materials by parent_id' do
+      get '/materials', params: { parent_id: material_a.id }
+
+      expect(response).to have_http_status(:ok)
+      expect(json['count']).to eq(1)
+      expect(response_materials.map { |m| m['id'] }).to eq([material_b.id])
+    end
+
+    it 'paginates and keeps total count' do
+      get '/materials', params: { page: 2, limit: 1 }
+
+      expect(response).to have_http_status(:ok)
+      expect(json['count']).to eq(2)
+      expect(response_materials.size).to eq(1)
+      expect(response_materials.first['id']).to eq(material_a.id)
+    end
+
+    it 'normalises invalid page and limit' do
+      get '/materials', params: { page: 0, limit: 0 }
+
+      expect(response).to have_http_status(:ok)
+      expect(json['count']).to eq(2)
+      expect(response_materials.size).to eq(1)
+      expect(response_materials.first['id']).to eq(material_b.id)
+    end
+  end
+
+  describe 'GET /materials/:id' do
+    let!(:tag) { Tag.create!(tag_name: TagName.create!(name: 'material_show'), category: :material) }
+    let!(:material) do
+      build_material(tag:, user: member_user, file: dummy_upload(filename: 'show.png'))
+    end
+
+    it 'returns a material with file, tag, and content_type' do
+      get "/materials/#{ material.id }"
+
+      expect(response).to have_http_status(:ok)
+      expect(json).to include(
+        'id' => material.id,
+        'content_type' => 'image/png'
+      )
+      expect(json['file']).to be_present
+      expect(json['tag']).to include(
+        'id' => tag.id,
+        'name' => 'material_show',
+        'category' => 'material'
+      )
+    end
+
+    it 'returns 404 when material does not exist' do
+      get '/materials/999999999'
+      expect(response).to have_http_status(:not_found)
+    end
+  end
+
+  describe 'POST /materials' do
+    context 'when not logged in' do
+      before { sign_out }
+
+      it 'returns 401' do
+        post '/materials', params: {
+          tag: 'material_create_unauthorized',
+          file: dummy_upload
+        }
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+
+    context 'when logged in' do
+      before { sign_in_as(guest_user) }
+
+      it 'returns 400 when tag is blank' do
+        post '/materials', params: { tag: '   ', file: dummy_upload }
+
+        expect(response).to have_http_status(:bad_request)
+      end
+
+      it 'returns 400 when both file and url are blank' do
+        post '/materials', params: { tag: 'material_create_blank' }
+
+        expect(response).to have_http_status(:bad_request)
+      end
+
+      it 'creates a material with an attached file' do
+        expect do
+          post '/materials', params: {
+            tag: 'material_create_new',
+            file: dummy_upload(filename: 'created.png')
+          }
+        end.to change(Material, :count).by(1)
+          .and change(Tag, :count).by(1)
+          .and change(TagName, :count).by(1)
+
+        expect(response).to have_http_status(:created)
+
+        material = Material.order(:id).last
+        expect(material.tag.name).to eq('material_create_new')
+        expect(material.tag.category).to eq('material')
+        expect(material.created_by_user).to eq(guest_user)
+        expect(material.updated_by_user).to eq(guest_user)
+        expect(material.file.attached?).to be(true)
+
+        expect(json['id']).to eq(material.id)
+        expect(json.dig('tag', 'name')).to eq('material_create_new')
+        expect(json['content_type']).to eq('image/png')
+      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)
+
+        post '/materials', params: {
+          tag: 'material_create_general_tag',
+          file: dummy_upload
+        }
+
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+
+      it 'persists url-only material' do
+        expect do
+          post '/materials', params: {
+            tag: 'material_create_url_only',
+            url: 'https://example.com/material-source'
+          }
+        end.to change(Material, :count).by(1)
+
+        expect(response).to have_http_status(:created)
+
+        material = Material.order(:id).last
+        expect(material.tag.name).to eq('material_create_url_only')
+        expect(material.url).to eq('https://example.com/material-source')
+        expect(material.file.attached?).to be(false)
+      end
+
+      it 'returns the original url for url-only material' do
+        post '/materials', params: {
+          tag: 'material_create_url_only_response',
+          url: 'https://example.com/material-source'
+        }
+
+        expect(response).to have_http_status(:created)
+        expect(json['url']).to eq('https://example.com/material-source')
+      end
+    end
+  end
+
+  describe 'PUT /materials/:id' do
+    let!(:tag) { Tag.create!(tag_name: TagName.create!(name: 'material_update_old'), category: :material) }
+    let!(:material) do
+      build_material(tag:, user: member_user, file: dummy_upload(filename: 'old.png'))
+    end
+
+    context 'when not logged in' do
+      before { sign_out }
+
+      it 'returns 401' do
+        put "/materials/#{ material.id }", params: {
+          tag: 'material_update_new',
+          file: dummy_upload(filename: 'new.png')
+        }
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+
+    context 'when logged in but not member' do
+      before { sign_in_as(guest_user) }
+
+      it 'returns 403' do
+        put "/materials/#{ material.id }", params: {
+          tag: 'material_update_new',
+          file: dummy_upload(filename: 'new.png')
+        }
+
+        expect(response).to have_http_status(:forbidden)
+      end
+    end
+
+    context 'when member' do
+      before { sign_in_as(member_user) }
+
+      it 'returns 404 when material does not exist' do
+        put '/materials/999999999', params: {
+          tag: 'material_update_missing',
+          file: dummy_upload
+        }
+
+        expect(response).to have_http_status(:not_found)
+      end
+
+      it 'returns 400 when tag is blank' do
+        put "/materials/#{ material.id }", params: {
+          tag: '   ',
+          file: dummy_upload
+        }
+
+        expect(response).to have_http_status(:bad_request)
+      end
+
+      it 'returns 400 when both file and url are blank' do
+        put "/materials/#{ material.id }", params: {
+          tag: 'material_update_no_payload'
+        }
+
+        expect(response).to have_http_status(:bad_request)
+      end
+
+      it 'updates tag, url, file, and updated_by_user' do
+        old_blob_id = material.file.blob.id
+
+        put "/materials/#{ material.id }", params: {
+          tag: 'material_update_new',
+          url: 'https://example.com/updated-source',
+          file: dummy_upload(filename: 'updated.jpg', type: 'image/jpeg')
+        }
+
+        expect(response).to have_http_status(:ok)
+
+        material.reload
+        expect(material.tag.name).to eq('material_update_new')
+        expect(material.tag.category).to eq('material')
+        expect(material.url).to eq('https://example.com/updated-source')
+        expect(material.updated_by_user).to eq(member_user)
+        expect(material.file.attached?).to be(true)
+        expect(material.file.blob.id).not_to eq(old_blob_id)
+        expect(material.file.blob.filename.to_s).to eq('updated.jpg')
+        expect(material.file.blob.content_type).to eq('image/jpeg')
+
+        expect(json['id']).to eq(material.id)
+        expect(json['file']).to be_present
+        expect(json['content_type']).to eq('image/jpeg')
+        expect(json.dig('tag', 'name')).to eq('material_update_new')
+      end
+
+      it 'purges the existing file when file is omitted and url is provided' do
+        old_blob_id = material.file.blob.id
+
+        put "/materials/#{ material.id }", params: {
+          tag: 'material_update_remove_file',
+          url: 'https://example.com/updated-source'
+        }
+
+        expect(response).to have_http_status(:ok)
+
+        material.reload
+        expect(material.tag.name).to eq('material_update_remove_file')
+        expect(material.url).to eq('https://example.com/updated-source')
+        expect(material.updated_by_user).to eq(member_user)
+        expect(material.file.attached?).to be(false)
+
+        expect(
+          ActiveStorage::Blob.where(id: old_blob_id).exists?
+        ).to be(false)
+
+        expect(json['id']).to eq(material.id)
+        expect(json['file']).to be_nil
+        expect(json['content_type']).to be_nil
+        expect(json.dig('tag', 'name')).to eq('material_update_remove_file')
+        expect(json['url']).to eq('https://example.com/updated-source')
+      end
+    end
+  end
+
+  describe 'DELETE /materials/:id' do
+    let!(:tag) { Tag.create!(tag_name: TagName.create!(name: 'material_destroy'), category: :material) }
+    let!(:material) do
+      build_material(tag:, user: member_user, file: dummy_upload(filename: 'destroy.png'))
+    end
+
+    context 'when not logged in' do
+      before { sign_out }
+
+      it 'returns 401' do
+        delete "/materials/#{ material.id }"
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+
+    context 'when logged in but not member' do
+      before { sign_in_as(guest_user) }
+
+      it 'returns 403' do
+        delete "/materials/#{ material.id }"
+        expect(response).to have_http_status(:forbidden)
+      end
+    end
+
+    context 'when member' do
+      before { sign_in_as(member_user) }
+
+      it 'returns 404 when material does not exist' do
+        delete '/materials/999999999'
+        expect(response).to have_http_status(:not_found)
+      end
+
+      it 'discards the material and returns 204' do
+        delete "/materials/#{ material.id }"
+
+        expect(response).to have_http_status(:no_content)
+        expect(Material.find_by(id: material.id)).to be_nil
+        expect(Material.with_discarded.find(material.id)).to be_discarded
+      end
+    end
+  end
+end

backend/spec/requests/nico_tags_spec.rb

@@ -14,6 +14,7 @@ RSpec.describe 'NicoTags', type: :request do
 
   describe 'PATCH /tags/nico/:id' do
     let(:member) { create(:user, :member) }
+    let(:admin) { create(:user, :admin) }
     let(:nico_tag) { create(:tag, :nico) }
 
     it '401 when not logged in' do
@@ -34,5 +35,59 @@ RSpec.describe 'NicoTags', type: :request do
       patch "/tags/nico/#{non_nico.id}", params: { tags: 'a b' }
       expect(response).to have_http_status(:bad_request)
     end
+
+    it '200 and updates linked tags while recording tag versions' do
+      sign_in_as(admin)
+
+      nico_tag_name = TagName.create!(name: 'nico:nico_tags_spec_source')
+      nico_tag = Tag.create!(tag_name: nico_tag_name, category: :nico)
+
+      linked_a_name = TagName.create!(name: 'nico_linked_a')
+      linked_a = Tag.create!(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)
+
+      TagVersioning.ensure_snapshot!(nico_tag, created_by_user: admin)
+
+      expect {
+        patch "/tags/nico/#{nico_tag.id}", params: {
+          tags: "  #{linked_a.name}\n#{linked_b.name}  "
+        }
+      }.to change(TagVersion, :count).by(2)
+       .and change(NicoTagVersion, :count).by(1)
+
+      expect(response).to have_http_status(:ok)
+
+      names = json.map { |t| t['name'] }
+      expect(names).to match_array(['nico_linked_a', 'nico_linked_b'])
+
+      linked_versions = TagVersion.where(tag: [linked_a, linked_b]).order(:tag_id)
+      expect(linked_versions.map(&:event_type)).to eq(['create', 'create'])
+      expect(linked_versions.map(&:created_by_user_id)).to all(eq(admin.id))
+
+      versions = nico_tag.reload.nico_tag_versions.order(:version_no)
+      expect(versions.map(&:event_type)).to eq(['create', 'update'])
+      expect(versions.last.linked_tags.split).to match_array([
+        'nico_linked_a',
+        'nico_linked_b'
+      ])
+      expect(versions.last.created_by_user_id).to eq(admin.id)
+    end
+
+    it '400 when linked tag normalises to nico tag' do
+      sign_in_as(member)
+
+      other_nico = create(:tag, :nico, name: 'nico:linked_ng')
+      TagName.create!(name: 'linked_ng_alias', canonical: other_nico.tag_name)
+
+      TagVersioning.ensure_snapshot!(nico_tag, created_by_user: member)
+
+      expect {
+        patch "/tags/nico/#{nico_tag.id}", params: { tags: 'linked_ng_alias' }
+      }.not_to change(NicoTagVersion, :count)
+
+      expect(response).to have_http_status(:bad_request)
+    end
   end
 end

backend/spec/requests/posts_spec.rb

@@ -1,8 +1,8 @@
-include ActiveSupport::Testing::TimeHelpers
-
 require 'rails_helper'
 require 'set'
 
+include ActiveSupport::Testing::TimeHelpers
+
 RSpec.describe 'Posts API', type: :request do
   # create / update で thumbnail.attach は走るが、
   # resized_thumbnail! が MiniMagick 依存でコケやすいので request spec ではスタブしとくのが無難。
@@ -756,6 +756,217 @@ RSpec.describe 'Posts API', type: :request do
     end
   end
 
+  describe 'GET /posts/versions' do
+    let(:member) { create(:user, :member, name: 'version member') }
+
+    let(:t_v1) { Time.zone.local(2020, 1, 1, 12, 0, 0) }
+    let(:t_v2) { Time.zone.local(2020, 1, 2, 12, 0, 0) }
+    let(:t_other) { Time.zone.local(2020, 1, 3, 12, 0, 0) }
+
+    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) }
+
+    def snapshot_tags(post)
+      post.snapshot_tag_names.join(' ')
+    end
+
+    def create_post_version!(post, version_no:, event_type:, created_by_user:, created_at:)
+      PostVersion.create!(
+        post: post,
+        version_no: version_no,
+        event_type: event_type,
+        title: post.title,
+        url: post.url,
+        thumbnail_base: post.thumbnail_base,
+        tags: snapshot_tags(post),
+        original_created_from: post.original_created_from,
+        original_created_before: post.original_created_before,
+        created_at: created_at,
+        created_by_user: created_by_user
+      )
+    end
+
+    let!(:v1) do
+      travel_to(t_v1) do
+        create_post_version!(
+          post_record,
+          version_no: 1,
+          event_type: 'create',
+          created_by_user: member,
+          created_at: t_v1
+        )
+      end
+    end
+
+    let!(:v2) do
+      post_record.post_tags.kept.find_by!(tag: tag).discard_by!(member)
+      PostTag.create!(post: post_record, tag: tag2, created_user: member)
+      post_record.update!(
+        title: 'updated spec post',
+        original_created_from: oc_from,
+        original_created_before: oc_before
+      )
+
+      travel_to(t_v2) do
+        create_post_version!(
+          post_record.reload,
+          version_no: 2,
+          event_type: 'update',
+          created_by_user: member,
+          created_at: t_v2
+        )
+      end
+    end
+
+    let!(:other_post_version) do
+      other_post = Post.create!(
+        title: 'other versioned post',
+        url: 'https://example.com/other-versioned'
+      )
+      PostTag.create!(post: other_post, tag: tag)
+
+      travel_to(t_other) do
+        create_post_version!(
+          other_post,
+          version_no: 1,
+          event_type: 'create',
+          created_by_user: member,
+          created_at: t_other
+        )
+      end
+    end
+
+    it 'returns versions for the specified post in reverse chronological order' do
+      get '/posts/versions', params: { post: post_record.id }
+
+      expect(response).to have_http_status(:ok)
+      expect(json).to include('versions', 'count')
+      expect(json.fetch('count')).to eq(2)
+
+      versions = json.fetch('versions')
+      expect(versions.map { |v| v['post_id'] }.uniq).to eq([post_record.id])
+      expect(versions.map { |v| v['version_no'] }).to eq([2, 1])
+
+      latest = versions.first
+      expect(latest).to include(
+        'post_id' => post_record.id,
+        'version_no' => 2,
+        'event_type' => 'update',
+        'created_by_user' => {
+          'id' => member.id,
+          'name' => member.name
+        }
+      )
+
+      expect(latest.fetch('title')).to eq(
+        'current' => 'updated spec post',
+        'prev' => 'spec post'
+      )
+      expect(latest.fetch('url')).to eq(
+        'current' => 'https://example.com/spec',
+        'prev' => 'https://example.com/spec'
+      )
+      expect(latest.fetch('thumbnail')).to eq(
+        'current' => nil,
+        'prev' => nil
+      )
+      expect(latest.fetch('thumbnail_base')).to eq(
+        'current' => nil,
+        'prev' => nil
+      )
+      expect(latest.fetch('tags')).to include(
+        { 'name' => 'spec_tag_2', 'type' => 'added' },
+        { 'name' => 'spec_tag', 'type' => 'removed' }
+      )
+      expect(latest.fetch('original_created_from')).to eq(
+        'current' => oc_from.iso8601,
+        'prev' => nil
+      )
+      expect(latest.fetch('original_created_before')).to eq(
+        'current' => oc_before.iso8601,
+        'prev' => nil
+      )
+      expect(latest.fetch('created_at')).to eq(t_v2.iso8601)
+
+      first = versions.second
+      expect(first).to include(
+        'post_id' => post_record.id,
+        'version_no' => 1,
+        'event_type' => 'create',
+        'created_by_user' => {
+          'id' => member.id,
+          'name' => member.name
+        }
+      )
+      expect(first.fetch('title')).to eq(
+        'current' => 'spec post',
+        'prev' => nil
+      )
+      expect(first.fetch('tags')).to include(
+        { 'name' => 'spec_tag', 'type' => 'added' }
+      )
+      expect(first.fetch('created_at')).to eq(t_v1.iso8601)
+    end
+
+    it 'filters versions by tag when the current snapshot includes the tag' do
+      get '/posts/versions', params: { post: post_record.id, tag: tag2.id }
+
+      expect(response).to have_http_status(:ok)
+      expect(json.fetch('count')).to eq(1)
+
+      versions = json.fetch('versions')
+      expect(versions.size).to eq(1)
+      expect(versions[0]['post_id']).to eq(post_record.id)
+      expect(versions[0]['version_no']).to eq(2)
+      expect(versions[0]['tags']).to include(
+        { 'name' => 'spec_tag_2', 'type' => 'added' }
+      )
+    end
+
+    it 'filters versions by tag when the tag exists in either current or previous snapshot' do
+      get '/posts/versions', params: { post: post_record.id, tag: tag.id }
+
+      expect(response).to have_http_status(:ok)
+      expect(json.fetch('count')).to eq(2)
+
+      versions = json.fetch('versions')
+      expect(versions.map { |v| v['post_id'] }).to all(eq(post_record.id))
+      expect(versions.map { |v| v['version_no'] }).to eq([2, 1])
+
+      latest = versions[0]
+      first = versions[1]
+
+      expect(latest['tags']).to include(
+        { 'name' => 'spec_tag', 'type' => 'removed' }
+      )
+      expect(first['tags']).to include(
+        { 'name' => 'spec_tag', 'type' => 'added' }
+      )
+    end
+
+    it 'returns empty when tag does not exist' do
+      get '/posts/versions', params: { tag: 999_999_999 }
+
+      expect(response).to have_http_status(:ok)
+      expect(json.fetch('versions')).to eq([])
+      expect(json.fetch('count')).to eq(0)
+    end
+
+    it 'clamps page and limit to at least 1' do
+      get '/posts/versions', params: { post: post_record.id, page: 0, limit: 0 }
+
+      expect(response).to have_http_status(:ok)
+      expect(json.fetch('count')).to eq(2)
+
+      versions = json.fetch('versions')
+      expect(versions.size).to eq(1)
+      expect(versions[0]['version_no']).to eq(2)
+    end
+  end
+
   describe 'POST /posts/:id/viewed' do
     let(:user) { create(:user) }
 
@@ -795,4 +1006,175 @@ RSpec.describe 'Posts API', type: :request do
       expect(user.reload.viewed?(post_record)).to be(false)
     end
   end
+
+  describe 'post versioning' do
+    let(:member) { create(:user, :member) }
+
+    def snapshot_tags(post)
+      post.snapshot_tag_names.join(' ')
+    end
+
+    def create_post_version_for!(post)
+      PostVersion.create!(
+        post: post,
+        version_no: 1,
+        event_type: 'create',
+        title: post.title,
+        url: post.url,
+        thumbnail_base: post.thumbnail_base,
+        tags: snapshot_tags(post),
+        original_created_from: post.original_created_from,
+        original_created_before: post.original_created_before,
+        created_at: post.created_at,
+        created_by_user: post.uploaded_user
+      )
+    end
+
+    it 'creates version 1 on POST /posts' do
+      sign_in_as(member)
+
+      expect do
+        post '/posts', params: {
+          title: 'versioned post',
+          url: 'https://example.com/versioned-post',
+          tags: 'spec_tag',
+          thumbnail: dummy_upload
+        }
+      end.to change(PostVersion, :count).by(1)
+
+      expect(response).to have_http_status(:created)
+
+      created_post = Post.find(json.fetch('id'))
+      version = PostVersion.find_by!(post: created_post, version_no: 1)
+
+      expect(version.event_type).to eq('create')
+      expect(version.title).to eq('versioned post')
+      expect(version.url).to eq('https://example.com/versioned-post')
+      expect(version.created_by_user_id).to eq(member.id)
+      expect(version.tags).to eq(snapshot_tags(created_post))
+    end
+
+    it 'creates next version on PUT /posts/:id when snapshot changes' do
+      sign_in_as(member)
+      create_post_version_for!(post_record)
+
+      tag_name2 = TagName.create!(name: 'spec_tag_2')
+      Tag.create!(tag_name: tag_name2, category: :general)
+
+      expect do
+        put "/posts/#{post_record.id}", params: {
+          title: 'updated title',
+          tags: 'spec_tag_2'
+        }
+      end.to change(PostVersion, :count).by(1)
+
+      expect(response).to have_http_status(:ok)
+
+      version = post_record.reload.post_versions.order(:version_no).last
+      expect(version.version_no).to eq(2)
+      expect(version.event_type).to eq('update')
+      expect(version.title).to eq('updated title')
+      expect(version.created_by_user_id).to eq(member.id)
+      expect(version.tags).to eq(snapshot_tags(post_record.reload))
+    end
+
+    it 'does not create a new version on PUT /posts/:id when snapshot is unchanged' do
+      sign_in_as(member)
+
+      PostTag.create!(post: post_record, tag: Tag.no_deerjikist)
+      create_post_version_for!(post_record.reload)
+
+      expect {
+        put "/posts/#{post_record.id}", params: {
+          title: post_record.title,
+          tags: 'spec_tag'
+        }
+      }.not_to change(PostVersion, :count)
+      expect(response).to have_http_status(:ok)
+
+      version = post_record.reload.post_versions.order(:version_no).last
+      expect(version.version_no).to eq(1)
+      expect(version.event_type).to eq('create')
+      expect(version.tags).to eq(snapshot_tags(post_record))
+    end
+
+    it 'does not create a version when POST /posts is invalid' do
+      sign_in_as(member)
+
+      expect do
+        post '/posts', params: {
+          title: 'invalid post',
+          url: 'ぼざクリタグ広場',
+          tags: 'spec_tag',
+          thumbnail: dummy_upload
+        }
+      end.not_to change(PostVersion, :count)
+
+      expect(response).to have_http_status(:unprocessable_entity)
+    end
+
+    it 'does not create a version when PUT /posts/:id is invalid' do
+      sign_in_as(member)
+      create_post_version_for!(post_record)
+
+      expect do
+        put "/posts/#{post_record.id}", params: {
+          title: 'updated title',
+          tags: 'spec_tag',
+          original_created_from: Time.zone.local(2020, 1, 2, 0, 0, 0).iso8601,
+          original_created_before: Time.zone.local(2020, 1, 1, 0, 0, 0).iso8601
+        }
+      end.not_to change(PostVersion, :count)
+
+      expect(response).to have_http_status(:unprocessable_entity)
+    end
+  end
+
+  describe 'tag versioning from post write actions' do
+    let(:member) { create(:user, :member) }
+
+    it 'creates tag snapshot for normalised tags on POST /posts' do
+      sign_in_as(member)
+
+      expect {
+        post '/posts', params: {
+          title: 'tag versioned post',
+          url: 'https://example.com/tag-versioned-post',
+          tags: 'spec_tag',
+          thumbnail: dummy_upload
+        }
+      }.to change { tag.reload.tag_versions.count }.by(1)
+
+      expect(response).to have_http_status(:created)
+
+      version = tag.reload.tag_versions.order(:version_no).last
+      expect(version.version_no).to eq(1)
+      expect(version.event_type).to eq('create')
+      expect(version.name).to eq('spec_tag')
+      expect(version.category).to eq('general')
+      expect(version.created_by_user_id).to eq(member.id)
+    end
+
+    it 'creates tag snapshot for normalised tags on PUT /posts/:id' do
+      sign_in_as(member)
+
+      tag_name2 = TagName.create!(name: 'spec_tag_2')
+      tag2 = Tag.create!(tag_name: tag_name2, category: :general)
+
+      expect {
+        put "/posts/#{post_record.id}", params: {
+          title: 'updated title',
+          tags: 'spec_tag_2'
+        }
+      }.to change { tag2.reload.tag_versions.count }.by(1)
+
+      expect(response).to have_http_status(:ok)
+
+      version = tag2.reload.tag_versions.order(:version_no).last
+      expect(version.version_no).to eq(1)
+      expect(version.event_type).to eq('create')
+      expect(version.name).to eq('spec_tag_2')
+      expect(version.created_by_user_id).to eq(member.id)
+    end
+  end
 end

backend/spec/requests/tag_children_spec.rb

@@ -58,15 +58,47 @@ RSpec.describe "TagChildren", type: :request do
       end
     end
 
-    context "when Tag.find raises (invalid ids) it still returns 204" do
+    context "when Tag.find raises (invalid ids)" do
       before { stub_current_user(admin) }
 
       let(:parent_id) { -1 }
       let(:child_id) { -1 }
 
-      it "returns 204 (rescue nil)" do
+      it "returns 404" do
         do_request
-        expect(response).to have_http_status(:no_content)
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+
+    context 'when parent is nico' do
+      before { stub_current_user(admin) }
+
+      let!(:parent) { create(:tag, :nico, name: 'nico:parent_ng') }
+      let(:parent_id) { parent.id }
+      let(:child_id) { child.id }
+
+      it 'returns 400 and does not create relation' do
+        expect {
+          do_request
+        }.not_to change(TagImplication, :count)
+
+        expect(response).to have_http_status(:bad_request)
+      end
+    end
+
+    context 'when child is nico' do
+      before { stub_current_user(admin) }
+
+      let!(:child) { create(:tag, :nico, name: 'nico:child_ng') }
+      let(:parent_id) { parent.id }
+      let(:child_id) { child.id }
+
+      it 'returns 400 and does not create relation' do
+        expect {
+          do_request
+        }.not_to change(TagImplication, :count)
+
+        expect(response).to have_http_status(:bad_request)
       end
     end
   end
@@ -116,17 +148,57 @@ RSpec.describe "TagChildren", type: :request do
 
         expect(response).to have_http_status(:no_content)
       end
+
+      it 'records create and update versions for child tag' do
+        expect {
+          do_request
+        }.to change(TagVersion, :count).by(2)
+
+        expect(response).to have_http_status(:no_content)
+
+        versions = child.reload.tag_versions.order(:version_no)
+        expect(versions.map(&:event_type)).to eq(['create', 'update'])
+        expect(versions.first.parent_tag_ids.split).to include(parent.id.to_s)
+        expect(versions.second.parent_tag_ids).to eq('')
+        expect(versions.second.created_by_user_id).to eq(admin.id)
+      end
     end
 
-    context "when Tag.find raises (invalid ids) it still returns 204" do
+    context "when Tag.find raises (invalid ids)" do
       before { stub_current_user(admin) }
 
       let(:parent_id) { -1 }
       let(:child_id) { -1 }
 
-      it "returns 204 (rescue nil)" do
+      it "returns 404" do
         do_request
-        expect(response).to have_http_status(:no_content)
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+
+    context 'when parent is nico' do
+      before { stub_current_user(admin) }
+
+      let!(:parent) { create(:tag, :nico, name: 'nico:parent_ng_delete') }
+      let(:parent_id) { parent.id }
+      let(:child_id) { child.id }
+
+      it 'returns 400' do
+        do_request
+        expect(response).to have_http_status(:bad_request)
+      end
+    end
+
+    context 'when child is nico' do
+      before { stub_current_user(admin) }
+
+      let!(:child) { create(:tag, :nico, name: 'nico:child_ng_delete') }
+      let(:parent_id) { parent.id }
+      let(:child_id) { child.id }
+
+      it 'returns 400' do
+        do_request
+        expect(response).to have_http_status(:bad_request)
       end
     end
   end

backend/spec/requests/tag_versions_spec.rb

@@ -0,0 +1,243 @@
+require 'rails_helper'
+
+RSpec.describe 'TagVersions API', type: :request do
+  let(:member) { create(:user, :member, name: 'version member') }
+
+  let!(:tag) { create(:tag, name: 'tag_versions_target', category: :general) }
+  let!(:other_tag) { create(:tag, name: 'tag_versions_other', category: :general) }
+
+  let!(:parent_shared) { create(:tag, name: 'parent_shared', category: :general) }
+  let!(:parent_old) { create(:tag, name: 'parent_old', category: :general) }
+  let!(:parent_new) { create(:tag, name: 'parent_new', category: :general) }
+  let!(:other_parent) { create(:tag, name: 'other_parent', category: :general) }
+
+  let(:t_v1) { Time.zone.local(2020, 1, 1, 12, 0, 0) }
+  let(:t_v2) { Time.zone.local(2020, 1, 2, 12, 0, 0) }
+  let(:t_other) { Time.zone.local(2020, 1, 3, 12, 0, 0) }
+
+  def create_tag_version!(
+    tag:,
+    version_no:,
+    event_type:,
+    name:,
+    category:,
+    aliases: [],
+    parent_tags: [],
+    created_by_user:,
+    created_at:
+  )
+    TagVersion.create!(
+      tag: tag,
+      version_no: version_no,
+      event_type: event_type,
+      name: name,
+      category: category,
+      aliases: Array(aliases).join(' '),
+      parent_tag_ids: Array(parent_tags).map(&:id).join(' '),
+      created_by_user: created_by_user,
+      created_at: created_at
+    )
+  end
+
+  let!(:v1) do
+    create_tag_version!(
+      tag: tag,
+      version_no: 1,
+      event_type: 'create',
+      name: 'old_tag_name',
+      category: 'general',
+      aliases: ['alias_shared', 'alias_old'],
+      parent_tags: [parent_shared, parent_old],
+      created_by_user: member,
+      created_at: t_v1
+    )
+  end
+
+  let!(:v2) do
+    create_tag_version!(
+      tag: tag,
+      version_no: 2,
+      event_type: 'update',
+      name: 'new_tag_name',
+      category: 'meme',
+      aliases: ['alias_shared', 'alias_new'],
+      parent_tags: [parent_shared, parent_new],
+      created_by_user: member,
+      created_at: t_v2
+    )
+  end
+
+  let!(:other_v1) do
+    create_tag_version!(
+      tag: other_tag,
+      version_no: 1,
+      event_type: 'create',
+      name: 'other_tag_name',
+      category: 'general',
+      aliases: ['other_alias'],
+      parent_tags: [other_parent],
+      created_by_user: member,
+      created_at: t_other
+    )
+  end
+
+  describe 'GET /tags/versions' do
+    it 'returns all versions in reverse chronological order when id is omitted' do
+      get '/tags/versions'
+
+      expect(response).to have_http_status(:ok)
+      expect(json).to include('versions', 'count')
+      expect(json.fetch('count')).to eq(3)
+
+      versions = json.fetch('versions')
+
+      expect(versions.map { |v| [v['tag_id'], v['version_no']] }).to eq([
+        [other_tag.id, 1],
+        [tag.id, 2],
+        [tag.id, 1]
+      ])
+    end
+
+    it 'returns versions for the specified tag with diffs' do
+      get '/tags/versions', params: { id: tag.id }
+
+      expect(response).to have_http_status(:ok)
+      expect(json).to include('versions', 'count')
+      expect(json.fetch('count')).to eq(2)
+
+      versions = json.fetch('versions')
+      expect(versions.map { |v| v['tag_id'] }.uniq).to eq([tag.id])
+      expect(versions.map { |v| v['version_no'] }).to eq([2, 1])
+
+      latest = versions.first
+      expect(latest).to include(
+        'tag_id' => tag.id,
+        'version_no' => 2,
+        'event_type' => 'update',
+        'created_by_user' => {
+          'id' => member.id,
+          'name' => member.name
+        }
+      )
+
+      expect(latest.fetch('name')).to eq(
+        'current' => 'new_tag_name',
+        'prev' => 'old_tag_name'
+      )
+      expect(latest.fetch('category')).to eq(
+        'current' => 'meme',
+        'prev' => 'general'
+      )
+      expect(latest.fetch('aliases')).to include(
+        { 'name' => 'alias_shared', 'type' => 'context' },
+        { 'name' => 'alias_new', 'type' => 'added' },
+        { 'name' => 'alias_old', 'type' => 'removed' }
+      )
+      expect(latest.fetch('parent_tags')).to include(
+        a_hash_including(
+          'type' => 'context',
+          'tag' => a_hash_including(
+            'id' => parent_shared.id
+          )
+        ),
+        a_hash_including(
+          'type' => 'added',
+          'tag' => a_hash_including(
+            'id' => parent_new.id
+          )
+        ),
+        a_hash_including(
+          'type' => 'removed',
+          'tag' => a_hash_including(
+            'id' => parent_old.id
+          )
+        )
+      )
+      expect(latest.fetch('created_at')).to eq(t_v2.iso8601)
+
+      first = versions.second
+      expect(first).to include(
+        'tag_id' => tag.id,
+        'version_no' => 1,
+        'event_type' => 'create',
+        'created_by_user' => {
+          'id' => member.id,
+          'name' => member.name
+        }
+      )
+      expect(first.fetch('name')).to eq(
+        'current' => 'old_tag_name',
+        'prev' => nil
+      )
+      expect(first.fetch('category')).to eq(
+        'current' => 'general',
+        'prev' => nil
+      )
+      expect(first.fetch('aliases')).to include(
+        { 'name' => 'alias_shared', 'type' => 'added' },
+        { 'name' => 'alias_old', 'type' => 'added' }
+      )
+      expect(first.fetch('parent_tags')).to include(
+        a_hash_including(
+          'type' => 'added',
+          'tag' => a_hash_including(
+            'id' => parent_shared.id
+          )
+        ),
+        a_hash_including(
+          'type' => 'added',
+          'tag' => a_hash_including(
+            'id' => parent_old.id
+          )
+        )
+      )
+      expect(first.fetch('created_at')).to eq(t_v1.iso8601)
+    end
+
+    it 'returns empty when the specified tag has no versions' do
+      fresh_tag = create(:tag, name: 'no_versions_tag', category: :general)
+
+      get '/tags/versions', params: { id: fresh_tag.id }
+
+      expect(response).to have_http_status(:ok)
+      expect(json.fetch('versions')).to eq([])
+      expect(json.fetch('count')).to eq(0)
+    end
+
+    it 'clamps page and limit to at least 1' do
+      get '/tags/versions', params: { id: tag.id, page: 0, limit: 0 }
+
+      expect(response).to have_http_status(:ok)
+      expect(json.fetch('count')).to eq(2)
+
+      versions = json.fetch('versions')
+      expect(versions.size).to eq(1)
+      expect(versions.first['version_no']).to eq(2)
+    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_page =
+          Wiki::Commit.create_content!(
+              tag_name: wiki_tag_name,
+              body: 'before',
+              created_by_user: member,
+              message: 'init')
+
+      Wiki::Commit.content!(
+          page: wiki_page,
+          body: 'after',
+          created_user: member,
+          message: 'edit',
+          base_revision_id: wiki_page.current_revision.id)
+
+      get '/tags/versions', params: { id: wiki_tag.id }
+
+      expect(response).to have_http_status(:ok)
+      expect(json.fetch('versions')).to eq([])
+      expect(json.fetch('count')).to eq(0)
+    end
+  end
+end

backend/spec/requests/tag_wiki_history_integrity_spec.rb

@@ -0,0 +1,160 @@
+require 'rails_helper'
+
+RSpec.describe 'Tag and wiki history integrity', type: :request do
+  let(:member_user) { create(:user, role: 'member') }
+
+  def stub_current_user user
+    allow_any_instance_of(ApplicationController).to receive(:current_user).and_return(user)
+  end
+
+  def create_tag! name:, category: :general
+    tag_name = TagName.create!(name:)
+    Tag.create!(tag_name:, category:)
+  end
+
+  def create_wiki_for_tag! tag:, body: 'wiki body', user: member_user
+    Wiki::Commit.create_content!(
+        tag_name: tag.tag_name,
+        body:,
+        created_by_user: user,
+        message: 'init')
+  end
+
+  before do
+    stub_current_user(member_user)
+  end
+
+  describe 'PATCH /tags/:id' do
+    it 'records wiki_version when tag name changes and tag has wiki' do
+      tag = create_tag!(name: 'patch_tag_wiki_before')
+      wiki_page = create_wiki_for_tag!(tag:, body: 'wiki body before')
+
+      expect {
+        patch "/tags/#{ tag.id }", params: {
+          name: 'patch_tag_wiki_after',
+        }
+      }
+          .to change(TagVersion, :count).by(2)
+          .and change(WikiVersion, :count).by(1)
+
+      expect(response).to have_http_status(:ok)
+
+      tag.reload
+      wiki_page.reload
+      version = wiki_page.wiki_versions.order(:version_no).last
+
+      expect(tag.name).to eq('patch_tag_wiki_after')
+      expect(wiki_page.title).to eq('patch_tag_wiki_after')
+
+      expect(version).to have_attributes(
+        event_type: 'update',
+        title: 'patch_tag_wiki_after',
+        body: 'wiki body before',
+        created_by_user_id: member_user.id
+      )
+    end
+
+    it 'does not record wiki_version when only category changes' do
+      tag = create_tag!(name: 'patch_tag_category_only')
+      wiki_page = create_wiki_for_tag!(tag:, body: 'wiki body before')
+
+      before_wiki_versions = wiki_page.wiki_versions.count
+
+      expect {
+        patch "/tags/#{ tag.id }", params: {
+          category: 'meme',
+        }
+      }
+          .to change(TagVersion, :count).by(2)
+
+      expect(response).to have_http_status(:ok)
+
+      tag.reload
+      wiki_page.reload
+
+      expect(tag.name).to eq('patch_tag_category_only')
+      expect(tag.category).to eq('meme')
+      expect(wiki_page.wiki_versions.count).to eq(before_wiki_versions)
+    end
+  end
+
+  describe 'PUT /tags/:id' do
+    it 'records wiki_version when tag name changes and tag has wiki' do
+      tag = create_tag!(name: 'put_tag_wiki_before')
+      wiki_page = create_wiki_for_tag!(tag:, body: 'wiki body before')
+
+      expect {
+        put "/tags/#{ tag.id }", params: {
+          name: 'put_tag_wiki_after',
+          category: 'general',
+          aliases: '',
+          parent_tags: '',
+        }
+      }
+          .to change(TagVersion, :count).by(2)
+          .and change(WikiVersion, :count).by(1)
+
+      expect(response).to have_http_status(:ok)
+
+      tag.reload
+      wiki_page.reload
+      version = wiki_page.wiki_versions.order(:version_no).last
+
+      expect(tag.name).to eq('put_tag_wiki_after')
+      expect(wiki_page.title).to eq('put_tag_wiki_after')
+
+      expect(version).to have_attributes(
+        event_type: 'update',
+        title: 'put_tag_wiki_after',
+        body: 'wiki body before',
+        created_by_user_id: member_user.id
+      )
+    end
+
+    it 'does not record wiki_version when only category changes' do
+      tag = create_tag!(name: 'put_tag_category_only')
+      wiki_page = create_wiki_for_tag!(tag:, body: 'wiki body before')
+
+      before_wiki_versions = wiki_page.wiki_versions.count
+
+      expect {
+        put "/tags/#{ tag.id }", params: {
+          name: 'put_tag_category_only',
+          category: 'meme',
+          aliases: '',
+          parent_tags: '',
+        }
+      }
+          .to change(TagVersion, :count).by(2)
+
+      expect(response).to have_http_status(:ok)
+
+      tag.reload
+      wiki_page.reload
+
+      expect(tag.name).to eq('put_tag_category_only')
+      expect(tag.category).to eq('meme')
+      expect(wiki_page.wiki_versions.count).to eq(before_wiki_versions)
+    end
+
+    it 'does not record wiki_version when only aliases change' do
+      tag = create_tag!(name: 'put_tag_alias_only')
+      wiki_page = create_wiki_for_tag!(tag:, body: 'wiki body before')
+
+      before_wiki_versions = wiki_page.wiki_versions.count
+
+      expect {
+        put "/tags/#{ tag.id }", params: {
+          name: 'put_tag_alias_only',
+          category: 'general',
+          aliases: 'put_tag_alias_only_alias',
+          parent_tags: '',
+        }
+      }
+          .to change(TagVersion, :count).by(2)
+
+      expect(response).to have_http_status(:ok)
+      expect(wiki_page.reload.wiki_versions.count).to eq(before_wiki_versions)
+    end
+  end
+end

backend/spec/requests/tags_spec.rb

@@ -1,7 +1,6 @@
 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) }
@@ -19,6 +18,17 @@ RSpec.describe 'Tags API', type: :request do
     response_tags.map { |t| t.fetch('name') }
   end
 
+  def dummy_material_upload(filename: 'dummy.png', type: 'image/png', body: 'dummy')
+    Rack::Test::UploadedFile.new(StringIO.new(body), type, original_filename: filename)
+  end
+
+  def create_material(tag, user:, filename: 'dummy.png', type: 'image/png', url: nil)
+    Material.new(tag:, url:, created_by_user: user, updated_by_user: user).tap do |material|
+      material.file.attach(dummy_material_upload(filename:, type:)) if filename
+      material.save!
+    end
+  end
+
   describe 'GET /tags' do
     it 'returns tags with count and metadata' do
       get '/tags'
@@ -186,6 +196,30 @@ RSpec.describe 'Tags API', type: :request do
       expect(response_tags.size).to eq(1)
       expect(response_names).to eq(['norm_a'])
     end
+
+    it 'returns aliases and parent tags' do
+      parent_tag = Tag.create!(
+        tag_name: TagName.create!(name: 'index_parent_tag'),
+        category: :meme
+      )
+      TagImplication.create!(tag:, parent_tag:)
+
+      get '/tags', params: { name: 'spec_tag' }
+
+      expect(response).to have_http_status(:ok)
+
+      row = response_tags.find { |t| t['name'] == 'spec_tag' }
+
+      expect(row['aliases']).to include('unko')
+      expect(row['parents'].map { |t| t['name'] }).to include('index_parent_tag')
+
+      parent = row['parents'].find { |t| t['name'] == 'index_parent_tag' }
+      expect(parent).to include(
+        'id' => parent_tag.id,
+        'name' => 'index_parent_tag',
+        'category' => 'meme'
+      )
+    end
   end
 
   describe 'GET /tags/:id' do
@@ -209,6 +243,28 @@ RSpec.describe 'Tags API', type: :request do
         expect(json).to have_key('created_at')
         expect(json).to have_key('updated_at')
       end
+
+      it 'returns aliases and parent tags' do
+        parent_tag = Tag.create!(
+          tag_name: TagName.create!(name: 'show_parent_tag'),
+          category: :character
+        )
+        TagImplication.create!(tag:, parent_tag:)
+
+        request
+
+        expect(response).to have_http_status(:ok)
+
+        expect(json['aliases']).to include('unko')
+        expect(json['parents'].map { |t| t['name'] }).to include('show_parent_tag')
+
+        parent = json['parents'].find { |t| t['name'] == 'show_parent_tag' }
+        expect(parent).to include(
+          'id' => parent_tag.id,
+          'name' => 'show_parent_tag',
+          'category' => 'character'
+        )
+      end
     end
 
     context 'when tag does not exist' do
@@ -348,14 +404,653 @@ RSpec.describe 'Tags API', type: :request do
         expect(tag.category).to eq('meta')
       end
 
-      it '存在しない id だと RecordNotFound になる（通常は 404）' do
+      it '存在しない id なら 404 を返す' do
         patch '/tags/999999999', params: { name: 'x' }
-        expect(response.status).to be_in([404, 500])
+        expect(response).to have_http_status(:not_found)
       end
 
-      it 'バリデーションで update! が失敗したら（通常は 422 か 500）' do
-        patch "/tags/#{ tag.id }", params: { name: 'new', category: 'nico' }
-        expect(response.status).to be_in([422, 500])
+      it 'nico category への変更は 422 を返す' do
+        patch "/tags/#{tag.id}", params: { name: 'new', category: 'nico' }
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(tag.reload.name).to eq('spec_tag')
+        expect(tag.category).to eq('general')
+      end
+
+      it 'creates initial and update tag versions when name and category change' do
+        expect {
+          patch "/tags/#{tag.id}", params: { name: 'new_tag_name', category: 'meme' }
+        }.to change(TagVersion, :count).by(2)
+
+        expect(response).to have_http_status(:ok)
+
+        versions = tag.reload.tag_versions.order(:version_no)
+
+        expect(versions.map(&:event_type)).to eq(['create', 'update'])
+
+        expect(versions.first.name).to eq('spec_tag')
+        expect(versions.first.category).to eq('general')
+        expect(versions.first.aliases.split).to include('unko')
+
+        expect(versions.second.name).to eq('new_tag_name')
+        expect(versions.second.category).to eq('meme')
+        expect(versions.second.created_by_user_id).to eq(member_user.id)
+      end
+
+      it 'returns 422 when changing normal tag category to nico' do
+        expect {
+          patch "/tags/#{tag.id}", params: { category: 'nico' }
+        }.not_to change(TagVersion, :count)
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(tag.reload.category).to eq('general')
+      end
+
+      it 'returns 422 when updating nico tag name' do
+        nico_tag_name = TagName.create!(name: 'nico:tags_spec_source')
+        nico_tag = Tag.create!(tag_name: nico_tag_name, category: :nico)
+
+        expect {
+          patch "/tags/#{ nico_tag.id }", params: { name: 'nico:tags_spec_renamed' }
+        }.not_to change(NicoTagVersion, :count)
+
+        expect(response).to have_http_status(:unprocessable_entity)
+
+        expect(nico_tag.reload.name).to eq('nico:tags_spec_source')
+        expect(nico_tag.category).to eq('nico')
+      end
+
+      it 'returns 422 when changing nico tag category to normal category' do
+        nico_tag_name = TagName.create!(name: 'nico:category_change_ng')
+        nico_tag = Tag.create!(tag_name: nico_tag_name, category: :nico)
+
+        expect {
+          patch "/tags/#{nico_tag.id}", params: { category: 'general' }
+        }.not_to change(NicoTagVersion, :count)
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(nico_tag.reload.category).to eq('nico')
+      end
+
+      it 'PATCH で tag の name を変更すると対応する wiki version を作成する' do
+        wiki_page =
+            Wiki::Commit.create_content!(
+                tag_name: tag.tag_name,
+                body: 'wiki body before',
+                created_by_user: member_user,
+                message: 'init')
+
+        expect {
+          patch "/tags/#{ tag.id }", params: {
+            name: 'patch_wiki_renamed_tag',
+          }
+        }
+            .to change(TagVersion, :count).by(2)
+            .and change(WikiVersion, :count).by(1)
+
+        expect(response).to have_http_status(:ok)
+
+        version = wiki_page.reload.wiki_versions.order(:version_no).last
+
+        expect(version).to have_attributes(
+          event_type: 'update',
+          title: 'patch_wiki_renamed_tag',
+          body: 'wiki body before',
+          created_by_user_id: member_user.id
+        )
+      end
+
+      it 'tag の category だけを変更しても wiki version は作成しない' do
+        wiki_page =
+            Wiki::Commit.create_content!(
+                tag_name: tag.tag_name,
+                body: 'wiki body before',
+                created_by_user: member_user,
+                message: 'init')
+
+        before_wiki_version_count = wiki_page.reload.wiki_versions.count
+
+        expect {
+          patch "/tags/#{ tag.id }", params: {
+            category: 'meme',
+          }
+        }.to change(TagVersion, :count).by(2)
+
+        expect(response).to have_http_status(:ok)
+        expect(wiki_page.reload.wiki_versions.count).to eq(before_wiki_version_count)
+      end
+    end
+  end
+
+  describe 'GET /tags/with-depth' do
+    let!(:root_meme) do
+      Tag.create!(tag_name: TagName.create!(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)
+    end
+
+    let!(:hidden_general_root) do
+      Tag.create!(tag_name: TagName.create!(name: 'depth_hidden_general_root'), category: :general)
+    end
+
+    let!(:child_character) do
+      Tag.create!(tag_name: TagName.create!(name: 'depth_child_character'), category: :character)
+    end
+
+    let!(:grandchild_material) do
+      Tag.create!(tag_name: TagName.create!(name: 'depth_grandchild_material'), category: :material)
+    end
+
+    let!(:child_general) do
+      Tag.create!(tag_name: TagName.create!(name: 'depth_child_general'), category: :general)
+    end
+
+    before do
+      TagImplication.create!(parent_tag: root_meme, tag: child_character)
+      TagImplication.create!(parent_tag: child_character, tag: grandchild_material)
+      TagImplication.create!(parent_tag: root_material, tag: child_general)
+    end
+
+    it 'returns only visible root tags and visible has_children flags' do
+      get '/tags/with-depth'
+
+      expect(response).to have_http_status(:ok)
+      expect(json.map { |t| t['name'] }).to eq([
+        'depth_a_root_meme',
+        'depth_b_root_material'
+      ])
+
+      meme_row = json.find { |t| t['name'] == 'depth_a_root_meme' }
+      material_row = json.find { |t| t['name'] == 'depth_b_root_material' }
+
+      expect(meme_row['has_children']).to eq(true)
+      expect(meme_row['children']).to eq([])
+
+      expect(material_row['has_children']).to eq(false)
+      expect(material_row['children']).to eq([])
+
+      expect(json.map { |t| t['name'] }).not_to include('depth_hidden_general_root')
+    end
+
+    it 'returns children of the specified parent' do
+      get '/tags/with-depth', params: { parent: root_meme.id }
+
+      expect(response).to have_http_status(:ok)
+      expect(json.map { |t| t['name'] }).to eq(['depth_child_character'])
+
+      row = json.first
+      expect(row['category']).to eq('character')
+      expect(row['has_children']).to eq(true)
+      expect(row['children']).to eq([])
+    end
+  end
+
+  describe 'GET /tags/name/:name/materials' do
+    let!(:material_user) { create_member_user! }
+
+    let!(:root_tag) do
+      Tag.create!(tag_name: TagName.create!(name: 'materials_root'), category: :material)
+    end
+
+    let!(:child_a_tag) do
+      Tag.create!(tag_name: TagName.create!(name: 'materials_child_a'), category: :material)
+    end
+
+    let!(:child_b_tag) do
+      Tag.create!(tag_name: TagName.create!(name: 'materials_child_b'), category: :character)
+    end
+
+    let!(:grandchild_tag) do
+      Tag.create!(tag_name: TagName.create!(name: 'materials_grandchild'), category: :material)
+    end
+
+    let!(:root_material) do
+      create_material(root_tag, user: material_user, filename: 'root.png')
+    end
+
+    let!(:child_a_material) do
+      create_material(child_a_tag, user: material_user, filename: 'child_a.png')
+    end
+
+    let!(:grandchild_material) do
+      create_material(grandchild_tag, user: material_user, filename: 'grandchild.png')
+    end
+
+    before do
+      TagImplication.create!(parent_tag: root_tag, tag: child_b_tag)
+      TagImplication.create!(parent_tag: root_tag, tag: child_a_tag)
+      TagImplication.create!(parent_tag: child_a_tag, tag: grandchild_tag)
+    end
+
+    it 'returns a tag tree with nested materials sorted by child name' do
+      get "/tags/name/#{ CGI.escape(root_tag.name) }/materials"
+
+      expect(response).to have_http_status(:ok)
+
+      expect(json).to include(
+        'id' => root_tag.id,
+        'name' => 'materials_root',
+        'category' => 'material'
+      )
+
+      expect(json['material']).to be_present
+      expect(json.dig('material', 'id')).to eq(root_material.id)
+      expect(json.dig('material', 'file')).to be_present
+      expect(json.dig('material', 'content_type')).to eq('image/png')
+
+      expect(json['children'].map { |t| t['name'] }).to eq([
+        'materials_child_a',
+        'materials_child_b'
+      ])
+
+      child_a = json['children'].find { |t| t['name'] == 'materials_child_a' }
+      child_b = json['children'].find { |t| t['name'] == 'materials_child_b' }
+
+      expect(child_a.dig('material', 'id')).to eq(child_a_material.id)
+      expect(child_a['children'].map { |t| t['name'] }).to eq(['materials_grandchild'])
+      expect(child_a.dig('children', 0, 'material', 'id')).to eq(grandchild_material.id)
+
+      expect(child_b['material']).to be_nil
+      expect(child_b['children']).to eq([])
+    end
+
+    it 'returns 404 when the tag does not exist' do
+      get '/tags/name/no_such_tag_12345/materials'
+      expect(response).to have_http_status(:not_found)
+    end
+  end
+
+  describe 'PUT /tags/:id' do
+    context '未ログイン' do
+      before { stub_current_user(nil) }
+
+      it '401 を返す' do
+        put "/tags/#{ tag.id }", params: {
+          name: 'new',
+          category: 'general',
+          aliases: '',
+          parent_tags: '',
+        }
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+
+    context 'ログインしてゐるが member でない' do
+      before { stub_current_user(non_member_user) }
+
+      it '403 を返す' do
+        put "/tags/#{ tag.id }", params: {
+          name: 'new',
+          category: 'general',
+          aliases: '',
+          parent_tags: '',
+        }
+
+        expect(response).to have_http_status(:forbidden)
+      end
+    end
+
+    context 'member' do
+      before { stub_current_user(member_user) }
+
+      it '存在しない id なら 404 を返す' do
+        put '/tags/999999999', params: {
+          name: 'new',
+          category: 'general',
+          aliases: '',
+          parent_tags: '',
+        }
+
+        expect(response).to have_http_status(:not_found)
+      end
+
+      it 'name が空なら 422 を返す' do
+        put "/tags/#{ tag.id }", params: {
+          name: '',
+          category: 'general',
+          aliases: '',
+          parent_tags: '',
+        }
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(tag.reload.name).to eq('spec_tag')
+      end
+
+      it 'category が空なら 422 を返す' do
+        put "/tags/#{ tag.id }", params: {
+          name: 'new',
+          category: '',
+          aliases: '',
+          parent_tags: '',
+        }
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(tag.reload.name).to eq('spec_tag')
+        expect(tag.category).to eq('general')
+      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
+        )
+        TagImplication.create!(tag:, parent_tag: old_parent)
+        TagImplication.create!(tag:, parent_tag: kept_parent)
+
+        put "/tags/#{ tag.id }", params: {
+          name: 'put_renamed_tag',
+          category: 'meme',
+          aliases: 'put_alias_a put_alias_b put_alias_a',
+          parent_tags: 'put_kept_parent put_new_parent',
+        }
+
+        expect(response).to have_http_status(:ok)
+
+        tag.reload
+
+        expect(tag.name).to eq('put_renamed_tag')
+        expect(tag.category).to eq('meme')
+
+        expect(TagName.find_by(name: 'put_alias_a').canonical).to eq(tag.tag_name)
+        expect(TagName.find_by(name: 'put_alias_b').canonical).to eq(tag.tag_name)
+
+        old_name_alias = TagName.find_by(name: 'spec_tag')
+        expect(old_name_alias).to be_present
+        expect(old_name_alias.canonical).to eq(tag.tag_name)
+
+        expect(alias_tn.reload.canonical).to be_nil
+
+        expect(tag.parents.map(&:name)).to contain_exactly(
+          'put_kept_parent',
+          'put_new_parent'
+        )
+
+        expect(TagImplication.where(tag:, parent_tag: old_parent)).not_to exist
+
+        expect(json['name']).to eq('put_renamed_tag')
+        expect(json['category']).to eq('meme')
+        expect(json['aliases']).to contain_exactly(
+          'put_alias_a',
+          'put_alias_b',
+          'spec_tag'
+        )
+        expect(json['parents'].map { |t| t['name'] }).to contain_exactly(
+          'put_kept_parent',
+          'put_new_parent'
+        )
+      end
+
+      it 'aliases に現在名を指定しても alias には残さない' do
+        put "/tags/#{ tag.id }", params: {
+          name: 'spec_tag',
+          category: 'general',
+          aliases: 'spec_tag put_alias_self_test',
+          parent_tags: '',
+        }
+
+        expect(response).to have_http_status(:ok)
+
+        tag.reload
+
+        expect(TagName.find_by(name: 'put_alias_self_test').canonical).to eq(tag.tag_name)
+        expect(json['aliases']).to include('put_alias_self_test')
+        expect(json['aliases']).not_to include('spec_tag')
+      end
+
+      it 'parent_tags に自分自身を指定しても自己参照は作らない' do
+        put "/tags/#{ tag.id }", params: {
+          name: 'spec_tag',
+          category: 'general',
+          aliases: 'unko',
+          parent_tags: 'spec_tag',
+        }
+
+        expect(response).to have_http_status(:ok)
+
+        expect(TagImplication.where(tag:, parent_tag: tag)).not_to exist
+        expect(tag.reload.parents).to eq([])
+      end
+
+      it 'initial and update tag versions を作成する' do
+        expect {
+          put "/tags/#{ tag.id }", params: {
+            name: 'put_versioned_tag',
+            category: 'meta',
+            aliases: '',
+            parent_tags: '',
+          }
+        }.to change(TagVersion, :count).by(2)
+
+        expect(response).to have_http_status(:ok)
+
+        versions = tag.reload.tag_versions.order(:version_no)
+
+        expect(versions.map(&:event_type)).to eq(['create', 'update'])
+
+        expect(versions.first.name).to eq('spec_tag')
+        expect(versions.first.category).to eq('general')
+        expect(versions.first.aliases.split).to include('unko')
+
+        expect(versions.second.name).to eq('put_versioned_tag')
+        expect(versions.second.category).to eq('meta')
+        expect(versions.second.aliases.split).to include('spec_tag')
+        expect(versions.second.created_by_user_id).to eq(member_user.id)
+      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
+        )
+        TagImplication.create!(tag:, parent_tag: old_parent)
+
+        put "/tags/#{ tag.id }", params: {
+          name: 'spec_tag',
+          category: 'general',
+          aliases: 'unko',
+          parent_tags: new_parent.name,
+        }
+
+        expect(response).to have_http_status(:ok)
+
+        expect(old_parent.reload.tag_versions.map(&:event_type)).to include('create')
+        expect(new_parent.reload.tag_versions.map(&:event_type)).to include('create')
+      end
+
+      it 'normal tag を nico category には変更できない' do
+        expect {
+          put "/tags/#{ tag.id }", params: {
+            name: 'spec_tag',
+            category: 'nico',
+            aliases: '',
+            parent_tags: '',
+          }
+        }.not_to change(TagVersion, :count)
+
+        expect(response).to have_http_status(:unprocessable_entity)
+
+        expect(tag.reload.name).to eq('spec_tag')
+        expect(tag.category).to eq('general')
+      end
+
+      it 'nico tag は更新できない' do
+        nico_tag = Tag.create!(
+          tag_name: TagName.create!(name: 'nico:put_update_all_ng'),
+          category: :nico
+        )
+
+        expect {
+          put "/tags/#{ nico_tag.id }", params: {
+            name: 'nico:put_update_all_renamed',
+            category: 'nico',
+            aliases: '',
+            parent_tags: '',
+          }
+        }.not_to change(NicoTagVersion, :count)
+
+        expect(response).to have_http_status(:unprocessable_entity)
+
+        expect(nico_tag.reload.name).to eq('nico:put_update_all_ng')
+        expect(nico_tag.category).to eq('nico')
+      end
+
+      it 'system tag の name は変更できない' do
+        system_tag = Tag.tagme
+        old_name = system_tag.name
+        old_category = system_tag.category
+
+        expect {
+          put "/tags/#{ system_tag.id }", params: {
+            name: 'put_system_tag_renamed',
+            category: old_category,
+            aliases: '',
+            parent_tags: '',
+          }
+        }.not_to change(TagVersion, :count)
+
+        expect(response).to have_http_status(:unprocessable_entity)
+
+        expect(system_tag.reload.name).to eq(old_name)
+        expect(system_tag.category).to eq(old_category)
+      end
+
+      it 'wiki を持つ tag を更新すると wiki version も作成する' do
+        wiki_page =
+            Wiki::Commit.create_content!(
+                tag_name: tag.tag_name,
+                body: 'wiki body before',
+                created_by_user: member_user,
+                message: 'init')
+
+        Wiki::Commit.content!(
+          page: wiki_page,
+          body: 'wiki body before',
+          created_user: member_user,
+          message: 'init'
+        )
+
+        expect {
+          put "/tags/#{ tag.id }", params: {
+            name: 'put_wiki_version_tag',
+            category: 'meme',
+            aliases: 'unko',
+            parent_tags: '',
+          }
+        }
+            .to change(TagVersion, :count).by(2)
+            .and change(WikiVersion, :count).by(1)
+
+        expect(response).to have_http_status(:ok)
+
+        version = wiki_page.reload.wiki_versions.order(:version_no).last
+
+        expect(version).to have_attributes(
+          event_type: 'update',
+          title: 'put_wiki_version_tag',
+          body: 'wiki body before',
+          created_by_user_id: member_user.id
+        )
+      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
+        )
+
+        expect(old_owner.tag_name.aliases.map(&:name)).to include('put_stolen_alias')
+
+        expect {
+          put "/tags/#{ tag.id }", params: {
+            name: 'spec_tag',
+            category: 'general',
+            aliases: 'unko put_stolen_alias',
+            parent_tags: '',
+          }
+        }
+            .to change { tag.reload.tag_versions.count }.by(2)
+            .and change { old_owner.reload.tag_versions.count }.by(2)
+
+        expect(response).to have_http_status(:ok)
+
+        expect(stolen_alias.reload.canonical).to eq(tag.tag_name)
+        expect(old_owner.reload.tag_name.aliases.map(&:name)).not_to include('put_stolen_alias')
+
+        old_owner_versions = old_owner.tag_versions.order(:version_no)
+
+        expect(old_owner_versions.first.event_type).to eq('create')
+        expect(old_owner_versions.first.aliases.split).to include('put_stolen_alias')
+
+        expect(old_owner_versions.second.event_type).to eq('update')
+        expect(old_owner_versions.second.aliases.split).not_to include('put_stolen_alias')
+      end
+
+      it 'parent_tags に指定すると循環する tag は 422 にする' do
+        pending '#332 で対応予定'
+
+        child = Tag.create!(
+          tag_name: TagName.create!(name: 'put_cycle_child'),
+          category: :general
+        )
+
+        TagImplication.create!(tag: child, parent_tag: tag)
+
+        put "/tags/#{ tag.id }", params: {
+          name: 'spec_tag',
+          category: 'general',
+          aliases: 'unko',
+          parent_tags: child.name,
+        }
+
+        expect(response).to have_http_status(:unprocessable_entity)
+
+        expect(TagImplication.where(tag:, parent_tag: child)).not_to exist
+      end
+
+      it 'tag の name を変更すると対応する wiki version を作成する' do
+        wiki_page =
+            Wiki::Commit.create_content!(
+                tag_name: tag.tag_name,
+                body: 'wiki body before',
+                created_by_user: member_user,
+                message: 'init')
+
+        expect {
+          put "/tags/#{ tag.id }", params: {
+            name: 'put_wiki_renamed_tag',
+            category: 'general',
+            aliases: 'unko',
+            parent_tags: '',
+          }
+        }
+            .to change(TagVersion, :count).by(2)
+            .and change(WikiVersion, :count).by(1)
+
+        expect(response).to have_http_status(:ok)
+
+        version = wiki_page.reload.wiki_versions.order(:version_no).last
+
+        expect(version).to have_attributes(
+          event_type: 'update',
+          title: 'put_wiki_renamed_tag',
+          body: 'wiki body before',
+          created_by_user_id: member_user.id
+        )
       end
     end
   end

backend/spec/requests/users_spec.rb

@@ -1,11 +1,10 @@
 require "rails_helper"
 
-
 RSpec.describe "Users", type: :request do
   describe "POST /users" do
     it "creates guest user and returns code" do
       post "/users"
-      expect(response).to have_http_status(:ok)
+      expect(response).to have_http_status(:created)
       expect(json["code"]).to be_present
       expect(json["user"]["role"]).to eq("guest")
     end
@@ -38,7 +37,7 @@ RSpec.describe "Users", type: :request do
       sign_in_as(user)
       put "/users/#{user.id}", params: { name: "new-name" }
 
-      expect(response).to have_http_status(:created)
+      expect(response).to have_http_status(:ok)
       expect(json["id"]).to eq(user.id)
       expect(json["name"]).to eq("new-name")
 

backend/spec/requests/wiki_body_search_pending_spec.rb

@@ -0,0 +1,27 @@
+require 'rails_helper'
+
+RSpec.describe 'Wiki body search', type: :request do
+  let!(:user) { create_member_user! }
+
+  it 'searches wiki pages by body text' do
+    pending '#336 で対応予定'
+
+    Wiki::Commit.create_content!(
+        tag_name: TagName.create!(name: 'wiki_body_search_hit'),
+        body: 'unique body keyword for wiki search',
+        created_by_user: user,
+        message: 'init')
+
+    Wiki::Commit.create_content!(
+        tag_name: TagName.create!(name: 'wiki_body_search_miss'),
+        body: 'ordinary body',
+        created_by_user: user,
+        message: 'init')
+
+    get '/wiki/search', params: { body: 'unique body keyword' }
+
+    expect(response).to have_http_status(:ok)
+    expect(json.map { |page| page['title'] }).to include('wiki_body_search_hit')
+    expect(json.map { |page| page['title'] }).not_to include('wiki_body_search_miss')
+  end
+end

backend/spec/requests/wiki_conflict_spec.rb

@@ -0,0 +1,42 @@
+require 'rails_helper'
+
+RSpec.describe 'Wiki conflict handling', type: :request do
+  let!(:user) { create_member_user! }
+
+  def auth_headers user
+    { 'X-Transfer-Code' => user.inheritance_code }
+  end
+
+  it 'returns 409 when base_revision_id is stale' do
+    page =
+        Wiki::Commit.create_content!(
+            tag_name: TagName.create!(name: 'wiki_conflict_request'),
+            body: 'first',
+            created_by_user: user,
+            message: 'init')
+
+    stale_id = page.current_revision.id
+
+    Wiki::Commit.content!(
+        page:,
+        body: 'second',
+        created_user: user,
+        message: 'other edit',
+        base_revision_id: stale_id)
+
+    put "/wiki/#{ page.id }",
+        params: {
+          title: 'wiki_conflict_request',
+          body: 'third',
+          message: 'stale',
+          base_revision_id: stale_id,
+        },
+        headers: auth_headers(user)
+
+    expect(response).to have_http_status(:conflict)
+
+    page.reload
+    expect(page.body).to eq('second')
+    expect(page.current_revision.message).to eq('other edit')
+  end
+end

backend/spec/requests/wiki_history_integrity_spec.rb

@@ -0,0 +1,196 @@
+require 'cgi'
+require 'rails_helper'
+
+RSpec.describe 'Wiki history integrity', type: :request do
+  let!(:user) { create_member_user! }
+
+  def auth_headers user
+    { 'X-Transfer-Code' => user.inheritance_code }
+  end
+
+  def create_wiki_page title:, body: 'body', message: 'init', user: self.user
+    Wiki::Commit.create_content!(
+        tag_name: TagName.create!(name: title),
+        body:,
+        created_by_user: user,
+        message:)
+  end
+
+  describe 'POST /wiki' do
+    it 'creates wiki_page, wiki_revision, and wiki_version atomically' do
+      expect {
+        post '/wiki',
+             params: {
+               title: 'wiki_history_create_atomic',
+               body: "a\nb\nc",
+               message: 'initial commit',
+             },
+             headers: auth_headers(user)
+      }
+          .to change(WikiPage, :count).by(1)
+          .and change(WikiRevision, :count).by(1)
+          .and change(WikiVersion, :count).by(1)
+
+      expect(response).to have_http_status(:created)
+
+      page = WikiPage.find(json.fetch('id'))
+      revision = page.current_revision
+      version = page.wiki_versions.order(:version_no).last
+
+      expect(page.title).to eq('wiki_history_create_atomic')
+      expect(page.body).to eq("a\nb\nc")
+
+      expect(revision).to be_content
+      expect(revision.message).to eq('initial commit')
+      expect(revision.lines_count).to eq(3)
+
+      expect(version).to have_attributes(
+        version_no: 1,
+        event_type: 'create',
+        title: 'wiki_history_create_atomic',
+        body: "a\nb\nc",
+        reason: 'initial commit',
+        created_by_user_id: user.id
+      )
+    end
+
+    it 'returns 422 and creates nothing when normalised body is blank' do
+      expect {
+        post '/wiki',
+             params: {
+               title: 'wiki_history_blank_body',
+               body: "\r\n\r\n",
+               message: 'blank',
+             },
+             headers: auth_headers(user)
+      }
+          .not_to change(WikiPage, :count)
+
+      expect(response).to have_http_status(:unprocessable_entity)
+      expect(WikiPage.joins(:tag_name).where(tag_names: { name: 'wiki_history_blank_body' })).not_to exist
+    end
+
+    it 'returns 422 and creates no partial page when title already exists' do
+      create_wiki_page(title: 'wiki_history_duplicate_title', body: 'first')
+
+      expect {
+        post '/wiki',
+             params: {
+               title: 'wiki_history_duplicate_title',
+               body: 'second',
+               message: 'duplicate',
+             },
+             headers: auth_headers(user)
+      }
+          .not_to change(WikiPage, :count)
+
+      expect(response).to have_http_status(:unprocessable_entity)
+      expect(WikiPage.joins(:tag_name).where(tag_names: { name: 'wiki_history_duplicate_title' }).count).to eq(1)
+    end
+  end
+
+  describe 'PUT /wiki/:id' do
+    it 'updates body and records wiki_revision and wiki_version' do
+      page = create_wiki_page(title: 'wiki_history_update_body', body: 'before')
+      current_id = page.current_revision.id
+
+      expect {
+        put "/wiki/#{ page.id }",
+            params: {
+              title: 'wiki_history_update_body',
+              body: 'after',
+              message: 'edit body',
+              base_revision_id: current_id,
+            },
+            headers: auth_headers(user)
+      }
+          .to change(WikiRevision, :count).by(1)
+          .and change(WikiVersion, :count).by(1)
+
+      expect(response).to have_http_status(:ok)
+
+      page.reload
+      version = page.wiki_versions.order(:version_no).last
+
+      expect(page.title).to eq('wiki_history_update_body')
+      expect(page.body).to eq('after')
+
+      expect(version).to have_attributes(
+        event_type: 'update',
+        title: 'wiki_history_update_body',
+        body: 'after',
+        reason: 'edit body',
+        created_by_user_id: user.id
+      )
+    end
+
+    it 'renames title and records wiki_version with new title' do
+      page = create_wiki_page(title: 'wiki_history_rename_before', body: 'before')
+      current_id = page.current_revision.id
+
+      expect {
+        put "/wiki/#{ page.id }",
+            params: {
+              title: 'wiki_history_rename_after',
+              body: 'after',
+              message: 'rename',
+              base_revision_id: current_id,
+            },
+            headers: auth_headers(user)
+      }
+          .to change(WikiRevision, :count).by(1)
+          .and change(WikiVersion, :count).by(1)
+
+      expect(response).to have_http_status(:ok)
+
+      page.reload
+      version = page.wiki_versions.order(:version_no).last
+
+      expect(page.title).to eq('wiki_history_rename_after')
+      expect(page.body).to eq('after')
+
+      expect(version).to have_attributes(
+        event_type: 'update',
+        title: 'wiki_history_rename_after',
+        body: 'after',
+        reason: 'rename',
+        created_by_user_id: user.id
+      )
+    end
+
+    it 'does not change title, body, revision, or version on stale base_revision_id' do
+      page = create_wiki_page(title: 'wiki_history_conflict_page', body: 'first')
+      stale_id = page.current_revision.id
+
+      Wiki::Commit.content!(
+          page:,
+          body: 'second',
+          created_user: user,
+          message: 'other edit',
+          base_revision_id: stale_id)
+
+      page.reload
+      current_title = page.title
+      current_body = page.body
+      revision_count = page.wiki_revisions.count
+      version_count = page.wiki_versions.count
+
+      put "/wiki/#{ page.id }",
+          params: {
+            title: 'wiki_history_conflict_renamed',
+            body: 'third',
+            message: 'stale edit',
+            base_revision_id: stale_id,
+          },
+          headers: auth_headers(user)
+
+      expect(response).to have_http_status(:conflict)
+
+      page.reload
+      expect(page.title).to eq(current_title)
+      expect(page.body).to eq(current_body)
+      expect(page.wiki_revisions.count).to eq(revision_count)
+      expect(page.wiki_versions.count).to eq(version_count)
+    end
+  end
+end

backend/spec/requests/wiki_restore_pending_spec.rb

@@ -0,0 +1,37 @@
+require 'rails_helper'
+
+RSpec.describe 'Wiki restore', type: :request do
+  let!(:user) { create_member_user! }
+
+  def auth_headers user
+    { 'X-Transfer-Code' => user.inheritance_code }
+  end
+
+  it 'restores wiki page to previous version' do
+    pending '#337 で対応予定'
+
+    page =
+        Wiki::Commit.create_content!(
+            tag_name: TagName.create!(name: 'wiki_restore_page'),
+            body: 'v1',
+            created_by_user: user,
+            message: 'init')
+
+    v1 = page.wiki_versions.order(:version_no).last
+
+    Wiki::Commit.content!(
+        page:,
+        body: 'v2',
+        created_user: user,
+        message: 'edit',
+        base_revision_id: page.current_revision.id)
+
+    post "/wiki/#{ page.id }/restore",
+         params: { version_no: v1.version_no },
+         headers: auth_headers(user)
+
+    expect(response).to have_http_status(:ok)
+    expect(page.reload.body).to eq('v1')
+    expect(page.wiki_versions.order(:version_no).last.event_type).to eq('restore')
+  end
+end

backend/spec/requests/wiki_spec.rb

@@ -4,13 +4,19 @@ require 'securerandom'
 
 
 RSpec.describe 'Wiki API', type: :request do
+  def auth_headers(user)
+    { 'X-Transfer-Code' => user.inheritance_code }
+  end
+
   let!(:user) { create_member_user! }
 
   let!(:tn) { TagName.create!(name: 'spec_wiki_title') }
   let!(:page) do
-    WikiPage.create!(tag_name: tn, created_user: user, updated_user: user).tap do |p|
-      Wiki::Commit.content!(page: p, body: 'init', created_user: user, message: 'init')
-    end
+    Wiki::Commit.create_content!(
+        tag_name: tn,
+        body: 'init',
+        created_by_user: user,
+        message: 'init')
   end
 
   describe 'GET /wiki' do
@@ -37,11 +43,12 @@ RSpec.describe 'Wiki API', type: :request do
     context 'when wiki page exists' do
       it 'returns wiki page with title' do
         request
+
         expect(response).to have_http_status(:ok)
 
         expect(json).to include(
-            'id'        => page.id,
-            'title'     => 'spec_wiki_title')
+            'id' => page.id,
+            'title' => 'spec_wiki_title')
       end
     end
 
@@ -50,6 +57,7 @@ RSpec.describe 'Wiki API', type: :request do
 
       it 'returns 404' do
         request
+
         expect(response).to have_http_status(:not_found)
       end
     end
@@ -97,8 +105,9 @@ RSpec.describe 'Wiki API', type: :request do
           post endpoint, params: { title: 'TestPage', body: "a\nb\nc", message: 'init' },
                          headers: auth_headers(member)
         end
-          .to change(WikiPage, :count).by(1)
-          .and change(WikiRevision, :count).by(1)
+            .to change(WikiPage, :count).by(1)
+            .and change(WikiRevision, :count).by(1)
+            .and change(WikiVersion, :count).by(1)
 
         expect(response).to have_http_status(:created)
 
@@ -106,16 +115,78 @@ RSpec.describe 'Wiki API', type: :request do
         expect(json.fetch('title')).to eq('TestPage')
         expect(json.fetch('body')).to eq("a\nb\nc")
 
-        page = WikiPage.find(page_id)
-        rev = page.current_revision
+        created_page = WikiPage.find(page_id)
+        version = created_page.wiki_versions.order(:version_no).last
+
+        expect(version).to have_attributes(
+          version_no: 1,
+          event_type: 'create',
+          title: 'TestPage',
+          body: "a\nb\nc",
+          created_by_user_id: member.id
+        )
+
+        rev = created_page.current_revision
         expect(rev).to be_present
         expect(rev).to be_content
         expect(rev.message).to eq('init')
 
-        expect(page.body).to eq("a\nb\nc")
+        expect(created_page.body).to eq("a\nb\nc")
+
         expect(rev.lines_count).to eq(3)
         expect(rev.wiki_revision_lines.order(:position).pluck(:position)).to eq([0, 1, 2])
-        expect(rev.wiki_lines.pluck(:body)).to match_array(%w[a b c])
+        expect(rev.wiki_lines.pluck(:body)).to match_array(['a', 'b', 'c'])
+      end
+
+      it 'reuses existing WikiLine rows by sha256' do
+        # 先に同じ行を作っておく
+        WikiLine.create!(sha256: Digest::SHA256.hexdigest('a'), body: 'a', created_at: Time.current, updated_at: Time.current)
+
+        post endpoint,
+             params: { title: 'Reuse', body: "a\na" },
+             headers: auth_headers(member)
+
+        page = WikiPage.find(JSON.parse(response.body).fetch('id'))
+        rev = page.current_revision
+        expect(rev.lines_count).to eq(2)
+
+        # "a" の WikiLine が増殖しない（1行のはず）
+        expect(WikiLine.where(body: 'a').count).to eq(1)
+      end
+
+      it 'deduplicates duplicated new lines before upsert' do
+        duplicated = 'duplicated_line_for_wiki_line_upsert_spec'
+
+        post endpoint,
+             params: { title: 'DuplicateNewLine', body: "#{ duplicated }\n#{ duplicated }" },
+             headers: auth_headers(member)
+
+        expect(response).to have_http_status(:created)
+
+        page = WikiPage.find(json.fetch('id'))
+        rev = page.current_revision
+
+        expect(rev.lines_count).to eq(2)
+        expect(WikiLine.where(body: duplicated).count).to eq(1)
+        expect(rev.wiki_revision_lines.count).to eq(2)
+        expect(rev.wiki_revision_lines.pluck(:wiki_line_id).uniq.size).to eq(1)
+      end
+
+      it 'normalises CRLF and strips trailing newlines' do
+        post endpoint,
+             params: { title: 'NormalisedBody', body: "a\r\nb\r\n\r\n", message: 'normalise' },
+             headers: auth_headers(member)
+
+        expect(response).to have_http_status(:created)
+
+        page = WikiPage.find(json.fetch('id'))
+        rev = page.current_revision
+        version = page.wiki_versions.order(:version_no).last
+
+        expect(page.body).to eq("a\nb")
+        expect(version.body).to eq("a\nb")
+        expect(rev.lines_count).to eq(2)
+        expect(rev.wiki_lines.order('wiki_revision_lines.position').map(&:body)).to eq(['a', 'b'])
       end
     end
   end
@@ -128,17 +199,14 @@ RSpec.describe 'Wiki API', type: :request do
       { 'X-Transfer-Code' => user.inheritance_code }
     end
 
-    #let!(:page) { create(:wiki_page, title: 'TestPage') }
-    let!(:page) do
-      build(:wiki_page, title: 'TestPage').tap do |p|
-        puts p.errors.full_messages unless p.valid?
-        p.save!
-      end
-    end
+    let!(:test_tag_name) { TagName.create!(name: 'TestPage') }
 
-    before do
-      # 初期版を 1 つ作っておく（更新が“2版目”になるように）
-      Wiki::Commit.content!(page: page, body: "a\nb", created_user: member, message: 'init')
+    let!(:page) do
+      Wiki::Commit.create_content!(
+          tag_name: test_tag_name,
+          body: "a\nb",
+          created_by_user: member,
+          message: 'init')
     end
 
     context 'when not logged in' do
@@ -164,14 +232,6 @@ RSpec.describe 'Wiki API', type: :request do
             headers: auth_headers(member)
         expect(response).to have_http_status(:unprocessable_entity)
       end
-
-      it 'returns 422 when title mismatched (if you forbid rename here)' do
-        put "/wiki/#{page.id}",
-            params: { title: 'OtherTitle', body: 'x' },
-            headers: auth_headers(member)
-        # 君の controller 例だと title 変更は 422 にしてた
-        expect(response).to have_http_status(:unprocessable_entity)
-      end
     end
 
     context 'when success' do
@@ -182,7 +242,18 @@ RSpec.describe 'Wiki API', type: :request do
           put "/wiki/#{page.id}",
               params: { title: 'TestPage', body: "x\ny", message: 'edit', base_revision_id: current_id },
               headers: auth_headers(member)
-        end.to change(WikiRevision, :count).by(1)
+        end
+            .to change(WikiRevision, :count).by(1)
+            .and change(WikiVersion, :count).by(1)
+
+        version = page.wiki_versions.order(:version_no).last
+
+        expect(version).to have_attributes(
+          event_type: 'update',
+          title: 'TestPage',
+          body: "x\ny",
+          created_by_user_id: member.id
+        )
 
         expect(response).to have_http_status(:ok)
 
@@ -193,25 +264,60 @@ RSpec.describe 'Wiki API', type: :request do
         expect(page.body).to eq("x\ny")
         expect(rev.base_revision_id).to eq(current_id)
       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)
+
+        TagVersionRecorder.record!(
+            tag: linked_tag,
+            event_type: :create,
+            created_by_user: member)
+
+        linked_page =
+            Wiki::Commit.create_content!(
+                tag_name: linked_tag_name,
+                body: 'before',
+                created_by_user: member,
+                message: 'init')
+
+        current_id = linked_page.current_revision.id
+        before_count = linked_tag.reload.tag_versions.count
+
+        expect {
+          put "/wiki/#{ linked_page.id }",
+              params: {
+                title: 'wiki_body_only_tag',
+                body: 'after',
+                message: 'edit',
+                base_revision_id: current_id,
+              },
+              headers: auth_headers(member)
+        }
+            .to change(WikiRevision, :count).by(1)
+            .and change(WikiVersion, :count).by(1)
+
+        expect(response).to have_http_status(:ok)
+        expect(linked_tag.reload.tag_versions.count).to eq(before_count)
+      end
     end
 
-    # TODO: コンフリクト未実装のため，実装したらコメント外す．
-    # context 'when conflict' do
-    #   it 'returns 409 when base_revision_id mismatches' do
-    #     # 先に別ユーザ（同じ member でもOK）が 1 回更新して先頭を進める
-    #     Wiki::Commit.content!(page: page, body: "zzz", created_user: member, message: 'other edit')
-    #     page.reload
+    context 'when conflict' do
+      it 'returns 409 when base_revision_id mismatches' do
+        # 先に別ユーザ（同じ member でもOK）が 1 回更新して先頭を進める
+        Wiki::Commit.content!(page: page, body: "zzz", created_user: member, message: 'other edit')
+        page.reload
 
-    #     stale_id = page.wiki_revisions.order(:id).first.id # わざと古い id
-    #     put "/wiki/#{page.id}",
-    #         params: { title: 'TestPage', body: 'x', base_revision_id: stale_id },
-    #         headers: auth_headers(member)
+        stale_id = page.wiki_revisions.order(:id).first.id # わざと古い id
+        put "/wiki/#{page.id}",
+            params: { title: 'TestPage', body: 'x', base_revision_id: stale_id },
+            headers: auth_headers(member)
 
-    #     expect(response).to have_http_status(:conflict)
-    #     json = JSON.parse(response.body)
-    #     expect(json['error']).to eq('conflict')
-    #   end
-    # end
+        expect(response).to have_http_status(:conflict)
+        json = JSON.parse(response.body)
+        expect(json['error']).to eq('conflict')
+      end
+    end
 
     context 'when page not found' do
       it 'returns 404' do
@@ -243,14 +349,17 @@ RSpec.describe 'Wiki API', type: :request do
 
   describe 'GET /wiki/search' do
     before do
-      # 追加で検索ヒット用
-      TagName.create!(name: 'spec_wiki_title_2')
-      WikiPage.create!(tag_name: TagName.find_by!(name: 'spec_wiki_title_2'),
-                       created_user: user, updated_user: user)
+      Wiki::Commit.create_content!(
+          tag_name: TagName.create!(name: 'spec_wiki_title_2'),
+          body: 'search body 2',
+          created_by_user: user,
+          message: 'init')
 
-      TagName.create!(name: 'unrelated_title')
-      WikiPage.create!(tag_name: TagName.find_by!(name: 'unrelated_title'),
-                       created_user: user, updated_user: user)
+      Wiki::Commit.create_content!(
+          tag_name: TagName.create!(name: 'unrelated_title'),
+          body: 'unrelated body',
+          created_by_user: user,
+          message: 'init')
     end
 
     it 'returns up to 20 pages filtered by title like' do
@@ -260,7 +369,9 @@ RSpec.describe 'Wiki API', type: :request do
       expect(json).to be_an(Array)
 
       titles = json.map { |p| p['title'] }
-      expect(titles).to include('spec_wiki_title', 'spec_wiki_title_2')
+
+      expect(titles).to include('spec_wiki_title')
+      expect(titles).to include('spec_wiki_title_2')
       expect(titles).not_to include('unrelated_title')
     end
 
@@ -311,7 +422,12 @@ 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')
-      p2 = WikiPage.create!(tag_name: tn2, created_user: user, updated_user: user)
+      # 異常データ: revision 無し WikiPage を直接作る
+      p2 = WikiPage.create!(
+          tag_name: tn2,
+          body: 'init',
+          created_user: user,
+          updated_user: user)
 
       get "/wiki/changes?id=#{p2.id}"
       expect(response).to have_http_status(:ok)
@@ -380,29 +496,68 @@ RSpec.describe 'Wiki API', type: :request do
       expect(json['older_revision_id']).to eq(rev_a.id)
       expect(json['newer_revision_id']).to eq(page.current_revision.id)
     end
+  end
 
-    it 'returns 422 when "to" is redirect revision' do
-      # redirect revision を作る
-      tn2 = TagName.create!(name: 'redirect_target')
-      target = WikiPage.create!(tag_name: tn2, created_user: user, updated_user: user)
+  describe 'Wiki::Commit.redirect!' do
+    it 'raises because redirect revisions are deprecated' do
+      target_tag_name = TagName.create!(name: 'redirect_deprecated_target')
+      target =
+          Wiki::Commit.create_content!(
+              tag_name: target_tag_name,
+              body: 'target',
+              created_by_user: user,
+              message: 'init')
 
-      Wiki::Commit.redirect!(page: page, redirect_page: target, created_user: user, message: 'redir')
-      redirect_rev = page.current_revision
-      expect(redirect_rev).to be_redirect
-
-      get "/wiki/#{page.id}/diff?from=#{rev_a.id}&to=#{redirect_rev.id}"
-      expect(response).to have_http_status(:unprocessable_entity)
-    end
-
-    it 'returns 422 when "from" is redirect revision' do
-      tn2 = TagName.create!(name: 'redirect_target2')
-      target = WikiPage.create!(tag_name: tn2, created_user: user, updated_user: user)
-
-      Wiki::Commit.redirect!(page: page, redirect_page: target, created_user: user, message: 'redir2')
-      redirect_rev = page.current_revision
-
-      get "/wiki/#{page.id}/diff?from=#{redirect_rev.id}&to=#{rev_b.id}"
-      expect(response).to have_http_status(:unprocessable_entity)
+      expect {
+        Wiki::Commit.redirect!(
+          page: page,
+          redirect_page: target,
+          created_user: user,
+          message: 'redirect',
+          base_revision_id: page.current_revision.id
+        )
+      }.to raise_error(RuntimeError, '廃止しました．')
     end
   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_page =
+        Wiki::Commit.create_content!(
+            tag_name: linked_tag_name,
+            body: 'before',
+            created_by_user: user,
+            message: 'init')
+
+    current_id = linked_page.current_revision.id
+
+    expect {
+      put "/wiki/#{ linked_page.id }",
+          params: {
+            title: 'wiki_linked_tag_for_version_renamed',
+            body: 'after',
+            message: 'rename',
+            base_revision_id: current_id,
+          },
+          headers: auth_headers(user)
+    }
+        .to change(WikiRevision, :count).by(1)
+        .and change(WikiVersion, :count).by(1)
+        .and change { linked_tag.reload.tag_versions.count }.by(2)
+
+    expect(response).to have_http_status(:ok)
+
+    linked_tag.reload
+    expect(linked_tag.name).to eq('wiki_linked_tag_for_version_renamed')
+
+    versions = linked_tag.tag_versions.order(:version_no)
+
+    expect(versions.first.event_type).to eq('create')
+    expect(versions.first.name).to eq('wiki_linked_tag_for_version')
+
+    expect(versions.second.event_type).to eq('update')
+    expect(versions.second.name).to eq('wiki_linked_tag_for_version_renamed')
+  end
 end

backend/spec/requests/wiki_title_collision_spec.rb

@@ -0,0 +1,62 @@
+require 'rails_helper'
+
+RSpec.describe 'Wiki title collision', type: :request do
+  let!(:user) { create_member_user! }
+
+  def auth_headers user
+    { 'X-Transfer-Code' => user.inheritance_code }
+  end
+
+  def create_wiki_page title:, body:
+    Wiki::Commit.create_content!(
+        tag_name: TagName.create!(name: title),
+        body:,
+        created_by_user: user,
+        message: 'init')
+  end
+
+  it 'returns 422 when renaming wiki title to existing title' do
+    source = create_wiki_page(title: 'wiki_collision_source', body: 'source body')
+    create_wiki_page(title: 'wiki_collision_target', body: 'target body')
+
+    source_revision_count = source.wiki_revisions.count
+    source_version_count = source.wiki_versions.count
+    old_title = source.title
+    old_body = source.body
+
+    put "/wiki/#{ source.id }",
+        params: {
+          title: 'wiki_collision_target',
+          body: 'new body',
+          message: 'rename collision',
+          base_revision_id: source.current_revision.id,
+        },
+        headers: auth_headers(user)
+
+    expect(response).to have_http_status(:unprocessable_entity)
+
+    source.reload
+
+    expect(source.title).to eq(old_title)
+    expect(source.body).to eq(old_body)
+    expect(source.wiki_revisions.count).to eq(source_revision_count)
+    expect(source.wiki_versions.count).to eq(source_version_count)
+  end
+
+  it 'returns 422 when creating wiki with existing title' do
+    create_wiki_page(title: 'wiki_collision_create', body: 'already exists')
+
+    expect {
+      post '/wiki',
+           params: {
+             title: 'wiki_collision_create',
+             body: 'new body',
+             message: 'duplicate create',
+           },
+           headers: auth_headers(user)
+    }
+        .not_to change(WikiPage, :count)
+
+    expect(response).to have_http_status(:unprocessable_entity)
+  end
+end

backend/spec/services/wiki/commit_integrity_spec.rb

@@ -0,0 +1,173 @@
+require 'digest'
+require 'rails_helper'
+
+RSpec.describe Wiki::Commit do
+  let(:user) { create_member_user! }
+
+  def create_page title:, body: 'initial body'
+    described_class.create_content!(
+        tag_name: TagName.create!(name: title),
+        body:,
+        created_by_user: user,
+        message: 'init')
+  end
+
+  describe '.create_content!' do
+    it 'creates page, revision, and version with normalised body' do
+      expect {
+        described_class.create_content!(
+            tag_name: TagName.create!(name: 'commit_integrity_create'),
+            body: "a\r\nb\r\n\r\n",
+            created_by_user: user,
+            message: 'init')
+      }
+          .to change(WikiPage, :count).by(1)
+          .and change(WikiRevision, :count).by(1)
+          .and change(WikiVersion, :count).by(1)
+
+      page = WikiPage.joins(:tag_name).find_by!(tag_names: { name: 'commit_integrity_create' })
+      revision = page.current_revision
+      version = page.wiki_versions.order(:version_no).last
+
+      expect(page.body).to eq("a\nb")
+      expect(revision.lines_count).to eq(2)
+      expect(version.body).to eq("a\nb")
+      expect(version.reason).to eq('init')
+    end
+
+    it 'rejects body that becomes blank after normalisation' do
+      tag_name = TagName.create!(name: 'commit_integrity_blank')
+
+      expect {
+        described_class.create_content!(
+            tag_name:,
+            body: "\r\n\r\n",
+            created_by_user: user,
+            message: 'blank')
+      }
+          .to raise_error(ActiveRecord::RecordInvalid)
+
+      expect(WikiPage.where(tag_name:)).not_to exist
+    end
+  end
+
+  describe '.content!' do
+    it 'updates page body, revision, and version' do
+      page = create_page(title: 'commit_integrity_update', body: 'before')
+      current_id = page.current_revision.id
+
+      expect {
+        described_class.content!(
+            page:,
+            body: 'after',
+            created_user: user,
+            message: 'edit',
+            base_revision_id: current_id)
+      }
+          .to change(WikiRevision, :count).by(1)
+          .and change(WikiVersion, :count).by(1)
+
+      page.reload
+      version = page.wiki_versions.order(:version_no).last
+
+      expect(page.body).to eq('after')
+      expect(version.body).to eq('after')
+      expect(version.reason).to eq('edit')
+    end
+
+    it 'does not record tag_version on body-only wiki update' do
+      tag_name = TagName.create!(name: 'commit_integrity_linked_tag')
+      tag = Tag.create!(tag_name:, category: :general)
+
+      page =
+          described_class.create_content!(
+              tag_name:,
+              body: 'before',
+              created_by_user: user,
+              message: 'init')
+
+      TagVersionRecorder.record!(
+          tag:,
+          event_type: :create,
+          created_by_user: user)
+
+      before_count = tag.reload.tag_versions.count
+
+      described_class.content!(
+          page:,
+          body: 'after',
+          created_user: user,
+          message: 'edit',
+          base_revision_id: page.current_revision.id)
+
+      expect(tag.reload.tag_versions.count).to eq(before_count)
+    end
+
+    it 'raises conflict and leaves page, revision, and version unchanged' do
+      page = create_page(title: 'commit_integrity_conflict', body: 'first')
+      stale_id = page.current_revision.id
+
+      described_class.content!(
+          page:,
+          body: 'second',
+          created_user: user,
+          message: 'second',
+          base_revision_id: stale_id)
+
+      page.reload
+      before_body = page.body
+      before_revision_count = page.wiki_revisions.count
+      before_version_count = page.wiki_versions.count
+
+      expect {
+        described_class.content!(
+            page:,
+            body: 'third',
+            created_user: user,
+            message: 'stale',
+            base_revision_id: stale_id)
+      }
+          .to raise_error(Wiki::Commit::Conflict)
+
+      page.reload
+      expect(page.body).to eq(before_body)
+      expect(page.wiki_revisions.count).to eq(before_revision_count)
+      expect(page.wiki_versions.count).to eq(before_version_count)
+    end
+
+    it 'deduplicates duplicated missing wiki lines' do
+      page = create_page(title: 'commit_integrity_dedup', body: 'before')
+      duplicated = 'commit_integrity_duplicate_line'
+
+      described_class.content!(
+          page:,
+          body: "#{ duplicated }\n#{ duplicated }",
+          created_user: user,
+          message: 'dedup',
+          base_revision_id: page.current_revision.id)
+
+      revision = page.reload.current_revision
+
+      expect(WikiLine.where(body: duplicated).count).to eq(1)
+      expect(revision.wiki_revision_lines.count).to eq(2)
+      expect(revision.wiki_revision_lines.pluck(:wiki_line_id).uniq.size).to eq(1)
+    end
+  end
+
+  describe '.redirect!' do
+    it 'raises because redirect revisions are deprecated' do
+      page = create_page(title: 'commit_integrity_redirect_source', body: 'source')
+      target = create_page(title: 'commit_integrity_redirect_target', body: 'target')
+
+      expect {
+        described_class.redirect!(
+            page:,
+            redirect_page: target,
+            created_user: user,
+            message: 'redirect',
+            base_revision_id: page.current_revision.id)
+      }
+          .to raise_error(RuntimeError, '廃止しました．')
+    end
+  end
+end

backend/spec/services/wiki/commit_spec.rb

@@ -0,0 +1,150 @@
+require 'rails_helper'
+
+RSpec.describe Wiki::Commit do
+  let(:user) { create_member_user! }
+
+  def create_page(title: 'commit_spec_page', body: 'initial body')
+    tag_name = TagName.create!(name: title)
+
+    Wiki::Commit.create_content!(
+        tag_name:,
+        body:,
+        created_by_user: user,
+        message: 'init')
+  end
+
+  describe '.content!' do
+    it 'stores normalised body in wiki_pages and wiki_versions' do
+      page = create_page(title: 'commit_normalised_page')
+
+      described_class.content!(
+        page:,
+        body: "a\r\nb\r\n\r\n",
+        created_user: user,
+        message: 'init'
+      )
+
+      page.reload
+      version = page.wiki_versions.order(:version_no).last
+
+      expect(page.body).to eq("a\nb")
+      expect(version.body).to eq("a\nb")
+      expect(page.current_revision.lines_count).to eq(2)
+    end
+
+    it 'deduplicates duplicated missing wiki lines before upsert' do
+      page = create_page(title: 'commit_duplicate_line_page')
+      duplicated = 'commit_duplicate_line'
+
+      described_class.content!(
+        page:,
+        body: "#{ duplicated }\n#{ duplicated }",
+        created_user: user,
+        message: 'init'
+      )
+
+      page.reload
+
+      expect(WikiLine.where(body: duplicated).count).to eq(1)
+      expect(page.current_revision.lines_count).to eq(2)
+      expect(page.current_revision.wiki_revision_lines.count).to eq(2)
+    end
+
+    it 'raises conflict when base_revision_id is stale' do
+      page = create_page(title: 'commit_conflict_page')
+
+      first = described_class.content!(
+        page:,
+        body: 'first',
+        created_user: user,
+        message: 'first'
+      )
+
+      described_class.content!(
+        page:,
+        body: 'second',
+        created_user: user,
+        message: 'second',
+        base_revision_id: first.id
+      )
+
+      expect {
+        described_class.content!(
+          page:,
+          body: 'third',
+          created_user: user,
+          message: 'third',
+          base_revision_id: first.id
+        )
+      }.to raise_error(Wiki::Commit::Conflict)
+    end
+
+    it 'does not record tag version when corresponding tag has no versions' do
+      tag_name = TagName.create!(name: 'commit_linked_tag_without_versions')
+      tag = Tag.create!(tag_name:, category: :general)
+
+      page =
+          described_class.create_content!(
+              tag_name:,
+              body: 'before',
+              created_by_user: user,
+              message: 'init')
+
+      expect(tag.reload.tag_versions.count).to eq(0)
+
+      current_revision_id = page.current_revision.id
+
+      expect {
+        described_class.content!(
+            page:,
+            body: 'after',
+            created_user: user,
+            message: 'edit',
+            base_revision_id: current_revision_id)
+      }.to change(WikiVersion, :count).by(1)
+
+      expect(tag.reload.tag_versions.count).to eq(0)
+    end
+
+    it 'does not record tag version when corresponding tag has no versions' do
+      tag_name = TagName.create!(name: 'commit_linked_tag_without_versions')
+      tag = Tag.create!(tag_name:, category: :general)
+
+      page =
+          described_class.create_content!(
+              tag_name:,
+              body: 'before',
+              created_by_user: user,
+              message: 'init')
+
+      current_revision_id = page.current_revision.id
+
+      expect {
+        described_class.content!(
+            page:,
+            body: 'after',
+            created_user: user,
+            message: 'edit',
+            base_revision_id: current_revision_id)
+      }.to change(WikiVersion, :count).by(1)
+
+      expect(tag.reload.tag_versions.count).to eq(0)
+    end
+  end
+
+  describe '.redirect!' do
+    it 'raises because redirect revisions are deprecated' do
+      page = create_page(title: 'commit_redirect_source')
+      target = create_page(title: 'commit_redirect_target')
+
+      expect {
+        described_class.redirect!(
+          page:,
+          redirect_page: target,
+          created_user: user,
+          message: 'redirect'
+        )
+      }.to raise_error(RuntimeError, '廃止しました．')
+    end
+  end
+end

backend/spec/services/wiki_version_recorder_spec.rb

@@ -0,0 +1,99 @@
+require 'rails_helper'
+
+RSpec.describe WikiVersionRecorder do
+  let(:user) { create_member_user! }
+
+  def create_page title:, body: 'body'
+    Wiki::Commit.create_content!(
+        tag_name: TagName.create!(name: title),
+        body:,
+        created_by_user: user,
+        message: 'init')
+  end
+
+  describe '.record!' do
+    it 'records title, body, reason, user, and version number' do
+      page = create_page(title: 'wiki_version_recorder_basic', body: 'body')
+
+      expect {
+        described_class.record!(
+            page:,
+            event_type: :update,
+            reason: 'manual reason',
+            created_by_user: user)
+      }
+          .to change { page.reload.wiki_versions.count }.by(1)
+
+      version = page.wiki_versions.order(:version_no).last
+
+      expect(version).to have_attributes(
+        version_no: 2,
+        event_type: 'update',
+        title: 'wiki_version_recorder_basic',
+        body: 'body',
+        reason: 'manual reason',
+        created_by_user_id: user.id
+      )
+    end
+
+    it 'does not create duplicated update version for identical snapshot' do
+      page = create_page(title: 'wiki_version_recorder_duplicate', body: 'body')
+
+      described_class.record!(
+          page:,
+          event_type: :update,
+          reason: nil,
+          created_by_user: user)
+
+      before_count = page.reload.wiki_versions.count
+
+      described_class.record!(
+          page:,
+          event_type: :update,
+          reason: nil,
+          created_by_user: user)
+
+      expect(page.reload.wiki_versions.count).to eq(before_count)
+    end
+
+    it 'creates update version when title changes' do
+      page = create_page(title: 'wiki_version_recorder_title_before', body: 'body')
+      page.tag_name.update!(name: 'wiki_version_recorder_title_after')
+
+      expect {
+        described_class.record!(
+            page:,
+            event_type: :update,
+            reason: 'rename',
+            created_by_user: user)
+      }
+          .to change { page.reload.wiki_versions.count }.by(1)
+
+      version = page.wiki_versions.order(:version_no).last
+
+      expect(version.title).to eq('wiki_version_recorder_title_after')
+      expect(version.body).to eq('body')
+      expect(version.reason).to eq('rename')
+    end
+
+    it 'creates update version when body changes' do
+      page = create_page(title: 'wiki_version_recorder_body', body: 'before')
+      page.update!(body: 'after')
+
+      expect {
+        described_class.record!(
+            page:,
+            event_type: :update,
+            reason: 'body',
+            created_by_user: user)
+      }
+          .to change { page.reload.wiki_versions.count }.by(1)
+
+      version = page.wiki_versions.order(:version_no).last
+
+      expect(version.title).to eq('wiki_version_recorder_body')
+      expect(version.body).to eq('after')
+      expect(version.reason).to eq('body')
+    end
+  end
+end

backend/spec/services/youtube/api_client_spec.rb

@@ -0,0 +1,130 @@
+require 'rails_helper'
+
+RSpec.describe Youtube::ApiClient do
+  let(:api_key) { 'test-api-key' }
+  let(:client) { described_class.new(api_key:) }
+
+  describe '#search_videos' do
+    it 'calls YouTube search API with expected params' do
+      published_after = Time.zone.parse('2026-05-01 00:00:00')
+      published_before = Time.zone.parse('2026-05-02 00:00:00')
+
+      expect(client).to receive(:get_json).with(
+        '/search',
+        {
+          part: 'snippet',
+          type: 'video',
+          q: 'ぼざろクリーチャー',
+          order: 'date',
+          maxResults: 50,
+          regionCode: 'JP',
+          relevanceLanguage: 'ja',
+          publishedAfter: published_after.iso8601,
+          publishedBefore: published_before.iso8601,
+          pageToken: 'NEXT'
+        }
+      ).and_return({ 'items' => [] })
+
+      client.search_videos(
+        q: 'ぼざろクリーチャー',
+        published_after:,
+        published_before:,
+        page_token: 'NEXT'
+      )
+    end
+
+    it 'omits nil optional params' do
+      expect(client).to receive(:get_json).with(
+        '/search',
+        hash_excluding(:publishedAfter, :publishedBefore, :pageToken)
+      ).and_return({ 'items' => [] })
+
+      client.search_videos(q: 'ぼざろクリーチャー')
+    end
+  end
+
+  describe '#videos' do
+    it 'returns empty items when ids are empty' do
+      expect(client).not_to receive(:get_json)
+
+      expect(client.videos([])).to eq({ 'items' => [] })
+    end
+
+    it 'calls videos API with comma separated ids' do
+      expect(client).to receive(:get_json).with(
+        '/videos',
+        {
+          part: 'snippet,status,contentDetails',
+          id: 'video-1,video-2'
+        }
+      ).and_return({ 'items' => [] })
+
+      client.videos(['video-1', 'video-2'])
+    end
+  end
+
+  describe '#playlist_items' do
+    it 'calls playlistItems API with page token' do
+      expect(client).to receive(:get_json).with(
+        '/playlistItems',
+        {
+          part: 'snippet,contentDetails,status',
+          playlistId: 'PL123',
+          maxResults: 50,
+          pageToken: 'NEXT'
+        }
+      ).and_return({ 'items' => [] })
+
+      client.playlist_items(playlist_id: 'PL123', page_token: 'NEXT')
+    end
+
+    it 'omits page token when nil' do
+      expect(client).to receive(:get_json).with(
+        '/playlistItems',
+        {
+          part: 'snippet,contentDetails,status',
+          playlistId: 'PL123',
+          maxResults: 50
+        }
+      ).and_return({ 'items' => [] })
+
+      client.playlist_items(playlist_id: 'PL123')
+    end
+  end
+
+  describe '#channel' do
+    it 'calls channels API by id' do
+      expect(client).to receive(:get_json).with(
+        '/channels',
+        {
+          part: 'snippet,contentDetails',
+          id: 'UC123'
+        }
+      ).and_return({ 'items' => [] })
+
+      client.channel(id: 'UC123')
+    end
+
+    it 'calls channels API by handle' do
+      expect(client).to receive(:get_json).with(
+        '/channels',
+        {
+          part: 'snippet,contentDetails',
+          forHandle: '@some_handle'
+        }
+      ).and_return({ 'items' => [] })
+
+      client.channel(handle: '@some_handle')
+    end
+
+    it 'raises when neither id nor handle is given' do
+      expect { client.channel }.to raise_error(ArgumentError, 'id or handle is required')
+    end
+
+    it 'raises when both id and handle are given' do
+      expect do
+        client.channel(id: 'UC123', handle: '@some_handle')
+      end.to raise_error(ArgumentError, 'id or handle is required')
+    end
+  end
+end

backend/spec/services/youtube/sync_spec.rb

@@ -0,0 +1,310 @@
+require 'rails_helper'
+
+RSpec.describe Youtube::Sync do
+  let(:client) { instance_double(Youtube::ApiClient) }
+  let(:sync) { described_class.new(client:) }
+
+  before do
+    allow(PostVersionRecorder).to receive(:record!)
+    allow(PostVersionRecorder).to receive(:ensure_snapshot!)
+    allow(sync).to receive(:attach_thumbnail_if_needed!)
+  end
+
+  describe '#sync!' do
+    it 'returns without fetching video details when no video ids are discovered' do
+      allow(sync).to receive(:query_terms).and_return([])
+      allow(sync).to receive(:playlist_ids).and_return([])
+
+      expect(client).not_to receive(:videos)
+
+      sync.sync!
+    end
+
+    it 'discovers ids from search and all playlist pages' do
+      allow(sync).to receive(:query_terms).and_return(['ぼざろクリーチャー'])
+      allow(sync).to receive(:playlist_ids).and_return(['PL123'])
+      allow(sync).to receive(:sync_since).and_return(Time.zone.parse('2026-05-01 00:00:00'))
+
+      allow(client).to receive(:search_videos).with(
+        q: 'ぼざろクリーチャー',
+        published_after: Time.zone.parse('2026-05-01 00:00:00')
+      ).and_return({
+        'items' => [
+          {
+            'id' => {
+              'videoId' => 'search-video-1'
+            }
+          }
+        ]
+      })
+
+      allow(client).to receive(:playlist_items).with(
+        playlist_id: 'PL123',
+        page_token: nil
+      ).and_return({
+        'items' => [
+          {
+            'contentDetails' => {
+              'videoId' => 'playlist-video-1'
+            }
+          }
+        ],
+        'nextPageToken' => 'NEXT'
+      })
+
+      allow(client).to receive(:playlist_items).with(
+        playlist_id: 'PL123',
+        page_token: 'NEXT'
+      ).and_return({
+        'items' => [
+          {
+            'snippet' => {
+              'resourceId' => {
+                'videoId' => 'playlist-video-2'
+              }
+            }
+          }
+        ]
+      })
+
+      expect(client).to receive(:videos).with(
+        satisfy do |ids|
+          ids.sort == ['playlist-video-1', 'playlist-video-2', 'search-video-1']
+        end
+      ).and_return({ 'items' => [] })
+
+      sync.sync!
+    end
+
+    it 'creates a YouTube post with default tags and no_deerjikist when no deerjikist mapping exists' do
+      Tag.tagme
+      Tag.bot
+      Tag.youtube
+      Tag.video
+      Tag.no_deerjikist
+
+      allow(sync).to receive(:query_terms).and_return([])
+      allow(sync).to receive(:playlist_ids).and_return(['PL123'])
+
+      allow(client).to receive(:playlist_items).with(
+        playlist_id: 'PL123',
+        page_token: nil
+      ).and_return({
+        'items' => [
+          {
+            'contentDetails' => {
+              'videoId' => 'video-1'
+            }
+          }
+        ]
+      })
+
+      allow(client).to receive(:videos).with(['video-1']).and_return({
+        'items' => [
+          youtube_video_item(
+            id: 'video-1',
+            title: 'YouTube テスト動画',
+            channel_id: 'UC_NO_MAPPING'
+          )
+        ]
+      })
+
+      expect do
+        sync.sync!
+      end.to change(Post, :count).by(1)
+
+      post = Post.find_by!(url: 'https://www.youtube.com/watch?v=video-1')
+      tag_ids = post.tags.pluck(:id)
+
+      expect(post.title).to eq('YouTube テスト動画')
+      expect(post.uploaded_user_id).to be_nil
+      expect(post.original_created_from).to eq(Time.zone.parse('2026-05-01 12:34:00'))
+      expect(post.original_created_before).to eq(Time.zone.parse('2026-05-01 12:35:00'))
+
+      expect(tag_ids).to include(Tag.tagme.id)
+      expect(tag_ids).to include(Tag.bot.id)
+      expect(tag_ids).to include(Tag.youtube.id)
+      expect(tag_ids).to include(Tag.video.id)
+      expect(tag_ids).to include(Tag.no_deerjikist.id)
+
+      expect(PostVersionRecorder).to have_received(:record!).with(
+        post:,
+        event_type: :create,
+        created_by_user: nil
+      )
+    end
+
+    it 'uses deerjikist tag when channel id is mapped' do
+      Tag.tagme
+      Tag.bot
+      Tag.youtube
+      Tag.video
+      Tag.no_deerjikist
+
+      deerjikist_tag = Tag.find_or_create_by_tag_name!('テスト投稿者', category: :deerjikist)
+      Deerjikist.create!(
+        platform: 'youtube',
+        code: 'UC_MAPPED',
+        tag: deerjikist_tag
+      )
+
+      allow(sync).to receive(:query_terms).and_return([])
+      allow(sync).to receive(:playlist_ids).and_return(['PL123'])
+
+      allow(client).to receive(:playlist_items).with(
+        playlist_id: 'PL123',
+        page_token: nil
+      ).and_return({
+        'items' => [
+          {
+            'contentDetails' => {
+              'videoId' => 'video-1'
+            }
+          }
+        ]
+      })
+
+      allow(client).to receive(:videos).with(['video-1']).and_return({
+        'items' => [
+          youtube_video_item(
+            id: 'video-1',
+            title: 'YouTube テスト動画',
+            channel_id: 'UC_MAPPED'
+          )
+        ]
+      })
+
+      sync.sync!
+
+      post = Post.find_by!(url: 'https://www.youtube.com/watch?v=video-1')
+      tag_ids = post.tags.pluck(:id)
+
+      expect(tag_ids).to include(deerjikist_tag.id)
+      expect(tag_ids).not_to include(Tag.no_deerjikist.id)
+    end
+
+    it 'removes no_deerjikist when deerjikist mapping is added later' do
+      Tag.no_deerjikist
+
+      post = Post.create!(
+        title: '旧タイトル',
+        url: 'https://www.youtube.com/watch?v=video-1',
+        uploaded_user_id: nil,
+        original_created_from: Time.zone.parse('2026-05-01 00:00:00'),
+        original_created_before: Time.zone.parse('2026-05-01 00:01:00')
+      )
+      PostTag.create!(post:, tag: Tag.no_deerjikist)
+
+      deerjikist_tag = Tag.find_or_create_by_tag_name!('後から判明した投稿者', category: :deerjikist)
+      Deerjikist.create!(
+        platform: 'youtube',
+        code: 'UC_MAPPED_LATER',
+        tag: deerjikist_tag
+      )
+
+      allow(sync).to receive(:query_terms).and_return([])
+      allow(sync).to receive(:playlist_ids).and_return(['PL123'])
+
+      allow(client).to receive(:playlist_items).with(
+        playlist_id: 'PL123',
+        page_token: nil
+      ).and_return({
+        'items' => [
+          {
+            'contentDetails' => {
+              'videoId' => 'video-1'
+            }
+          }
+        ]
+      })
+
+      allow(client).to receive(:videos).with(['video-1']).and_return({
+        'items' => [
+          youtube_video_item(
+            id: 'video-1',
+            title: '新タイトル',
+            channel_id: 'UC_MAPPED_LATER'
+          )
+        ]
+      })
+
+      sync.sync!
+
+      post.reload
+      tag_ids = post.tags.pluck(:id)
+
+      expect(post.title).to eq('新タイトル')
+      expect(tag_ids).to include(deerjikist_tag.id)
+      expect(tag_ids).not_to include(Tag.no_deerjikist.id)
+
+      expect(PostVersionRecorder).to have_received(:ensure_snapshot!).with(
+        post,
+        created_by_user: nil
+      )
+      expect(PostVersionRecorder).to have_received(:record!).with(
+        post:,
+        event_type: :update,
+        created_by_user: nil
+      )
+    end
+
+    it 'matches existing youtu.be URL and does not create duplicate post' do
+      post = Post.create!(
+        title: '旧タイトル',
+        url: 'https://youtu.be/video-1',
+        uploaded_user_id: nil,
+        original_created_from: Time.zone.parse('2026-05-01 00:00:00'),
+        original_created_before: Time.zone.parse('2026-05-01 00:01:00')
+      )
+
+      allow(sync).to receive(:query_terms).and_return([])
+      allow(sync).to receive(:playlist_ids).and_return(['PL123'])
+
+      allow(client).to receive(:playlist_items).with(
+        playlist_id: 'PL123',
+        page_token: nil
+      ).and_return({
+        'items' => [
+          {
+            'contentDetails' => {
+              'videoId' => 'video-1'
+            }
+          }
+        ]
+      })
+
+      allow(client).to receive(:videos).with(['video-1']).and_return({
+        'items' => [
+          youtube_video_item(
+            id: 'video-1',
+            title: '新タイトル',
+            channel_id: 'UC_NO_MAPPING'
+          )
+        ]
+      })
+
+      expect do
+        sync.sync!
+      end.not_to change(Post, :count)
+
+      expect(post.reload.title).to eq('新タイトル')
+    end
+  end
+
+  def youtube_video_item(id:, title:, channel_id:)
+    {
+      'id' => id,
+      'snippet' => {
+        'title' => title,
+        'channelId' => channel_id,
+        'publishedAt' => '2026-05-01T12:34:56Z',
+        'thumbnails' => {
+          'high' => {
+            'url' => "https://img.youtube.com/#{id}.jpg"
+          }
+        },
+        'tags' => ['tag-a', 'tag-b']
+      }
+    }
+  end
+end

backend/spec/services/youtube/video_item_spec.rb

@@ -0,0 +1,93 @@
+require 'rails_helper'
+
+RSpec.describe Youtube::VideoItem do
+  describe '#initialize' do
+    it 'extracts fields from YouTube video API item' do
+      item = {
+        'id' => 'video-1',
+        'snippet' => {
+          'title' => 'テスト動画',
+          'channelId' => 'UC123',
+          'publishedAt' => '2026-05-01T12:34:56Z',
+          'tags' => ['tag-a', 'tag-b'],
+          'thumbnails' => {
+            'high' => {
+              'url' => 'https://img.youtube.com/high.jpg'
+            },
+            'medium' => {
+              'url' => 'https://img.youtube.com/medium.jpg'
+            }
+          }
+        }
+      }
+
+      video = described_class.new(item)
+
+      expect(video.id).to eq('video-1')
+      expect(video.title).to eq('テスト動画')
+      expect(video.channel_id).to eq('UC123')
+      expect(video.published_at).to eq(Time.iso8601('2026-05-01T12:34:56Z'))
+      expect(video.thumbnail_url).to eq('https://img.youtube.com/high.jpg')
+      expect(video.raw_tags).to eq(['tag-a', 'tag-b'])
+      expect(video.url).to eq('https://www.youtube.com/watch?v=video-1')
+    end
+
+    it 'uses highest priority thumbnail' do
+      item = {
+        'id' => 'video-1',
+        'snippet' => {
+          'title' => 'テスト動画',
+          'channelId' => 'UC123',
+          'publishedAt' => '2026-05-01T12:34:56Z',
+          'thumbnails' => {
+            'default' => {
+              'url' => 'https://img.youtube.com/default.jpg'
+            },
+            'standard' => {
+              'url' => 'https://img.youtube.com/standard.jpg'
+            },
+            'maxres' => {
+              'url' => 'https://img.youtube.com/maxres.jpg'
+            }
+          }
+        }
+      }
+
+      video = described_class.new(item)
+
+      expect(video.thumbnail_url).to eq('https://img.youtube.com/maxres.jpg')
+    end
+
+    it 'falls back to empty raw tags' do
+      item = {
+        'id' => 'video-1',
+        'snippet' => {
+          'title' => 'テスト動画',
+          'channelId' => 'UC123',
+          'publishedAt' => '2026-05-01T12:34:56Z',
+          'thumbnails' => {}
+        }
+      }
+
+      video = described_class.new(item)
+
+      expect(video.raw_tags).to eq([])
+    end
+
+    it 'returns nil thumbnail when no thumbnail exists' do
+      item = {
+        'id' => 'video-1',
+        'snippet' => {
+          'title' => 'テスト動画',
+          'channelId' => 'UC123',
+          'publishedAt' => '2026-05-01T12:34:56Z',
+          'thumbnails' => {}
+        }
+      }
+
+      video = described_class.new(item)
+
+      expect(video.thumbnail_url).to be_nil
+    end
+  end
+end

backend/spec/support/test_records.rb

@@ -3,13 +3,13 @@ module TestRecords
     User.create!(name: 'spec user',
                  inheritance_code: SecureRandom.hex(16),
                  role: 'member',
-                 banned: false)
+                 banned_at: nil)
   end
 
   def create_admin_user!
     User.create!(name: 'spec admin',
                  inheritance_code: SecureRandom.hex(16),
                  role: 'admin',
-                 banned: false)
+                 banned_at: nil)
   end
 end

backend/spec/tasks/nico_export_spec.rb

@@ -0,0 +1,100 @@
+require 'rails_helper'
+require 'rake'
+require 'open3'
+
+RSpec.describe 'nico:export' do
+  let(:task) { Rake::Task['nico:export'] }
+  let(:success_status) { instance_double(Process::Status, success?: true) }
+  let(:failure_status) { instance_double(Process::Status, success?: false) }
+
+  def create_post(url)
+    Post.create!(url:)
+  end
+
+  before(:all) do
+    Rails.application.load_tasks unless Rake::Task.task_defined?('nico:export')
+  end
+
+  before do
+    task.reenable
+
+    allow(ENV).to receive(:fetch).with('MYSQL_USER').and_return('mysql-user')
+    allow(ENV).to receive(:fetch).with('MYSQL_PASS').and_return('mysql-pass')
+    allow(ENV).to receive(:fetch).with('NIZIKA_NICO_PATH').and_return('/srv/nizika-nico')
+  end
+
+  describe 'export' do
+    it 'exports nicovideo ids to shared nico DB' do
+      create_post('https://www.nicovideo.jp/watch/sm12345?ref=foo')
+      create_post('https://www.nicovideo.jp/watch/so67890#comments')
+      create_post('https://www.nicovideo.jp/watch/nm24680')
+      create_post('https://example.com/watch/sm99999')
+
+      expect(Open3).to receive(:capture3) do |env, *args, **kwargs|
+        expect(env).to eq(
+          {
+            'MYSQL_USER' => 'mysql-user',
+            'MYSQL_PASS' => 'mysql-pass',
+          },
+        )
+
+        expect(args.take(3)).to eq(
+          [
+            'python3',
+            '-m',
+            'tracked_videos.put_bulk_upsert',
+          ],
+        )
+
+        expect(args.drop(3)).to contain_exactly(
+          'sm12345',
+          'so67890',
+          'nm24680',
+        )
+
+        expect(kwargs).to eq(chdir: '/srv/nizika-nico')
+
+        ['', '', success_status]
+      end
+
+      task.invoke
+    end
+
+    it 'deduplicates video ids' do
+      create_post('https://www.nicovideo.jp/watch/sm12345')
+      create_post('https://www.nicovideo.jp/watch/sm12345?from=1')
+
+      expect(Open3).to receive(:capture3) do |_env, *args, **_kwargs|
+        expect(args.drop(3)).to eq(['sm12345'])
+
+        ['', '', success_status]
+      end
+
+      task.invoke
+    end
+
+    it 'does not call python when there are no nicovideo posts' do
+      create_post('https://example.com/watch/sm12345')
+
+      expect(Open3).not_to receive(:capture3)
+
+      task.invoke
+    end
+
+    it 'raises stderr when python command fails' do
+      create_post('https://www.nicovideo.jp/watch/sm12345')
+
+      allow(Open3).to receive(:capture3).and_return(
+        [
+          '',
+          'bulk upsert failed',
+          failure_status,
+        ],
+      )
+
+      expect {
+        task.invoke
+      }.to raise_error(RuntimeError, 'bulk upsert failed')
+    end
+  end
+end

backend/spec/tasks/nico_sync_spec.rb

@@ -90,4 +90,231 @@ RSpec.describe "nico:sync" do
     expect(active_names).to include("nico:NEW")
     expect(active_names).not_to include("nico:OLD")
   end
+
+  def snapshot_tags(post)
+    post.snapshot_tag_names.join(' ')
+  end
+
+  def create_post_version_for!(post, version_no: 1, event_type: 'create', created_by_user: nil)
+    PostVersion.create!(
+      post: post,
+      version_no: version_no,
+      event_type: event_type,
+      title: post.title,
+      url: post.url,
+      thumbnail_base: post.thumbnail_base,
+      tags: snapshot_tags(post),
+      original_created_from: post.original_created_from,
+      original_created_before: post.original_created_before,
+      created_at: Time.current,
+      created_by_user: created_by_user
+    )
+  end
+
+  it '新規 post 作成時に version 1 を作る' do
+    Tag.bot
+    Tag.tagme
+    Tag.niconico
+    Tag.video
+    Tag.no_deerjikist
+
+    stub_python([{
+      'code' => 'sm9',
+      'title' => 't',
+      'tags' => ['AAA'],
+      'uploaded_at' => '2026-01-01 12:34:56'
+    }])
+
+    allow(URI).to receive(:open).and_return(StringIO.new('<html></html>'))
+
+    expect {
+      run_rake_task('nico:sync')
+    }.to change(PostVersion, :count).by(1)
+
+    post = Post.find_by!(url: 'https://www.nicovideo.jp/watch/sm9')
+    version = post.post_versions.order(:version_no).last
+
+    expect(version.version_no).to eq(1)
+    expect(version.event_type).to eq('create')
+    expect(version.created_by_user).to be_nil
+    expect(version.tags).to eq(snapshot_tags(post.reload))
+  end
+
+  it '既存 post の内容または tags が変わったとき update version を作る' do
+    post = Post.create!(
+      title: 'old',
+      url: 'https://www.nicovideo.jp/watch/sm9',
+      uploaded_user: nil
+    )
+
+    kept_general = create_tag!('spec_kept', category: 'general')
+    PostTag.create!(post: post, tag: kept_general)
+    create_post_version_for!(post)
+
+    linked = create_tag!('spec_linked', category: 'general')
+    nico = create_tag!('nico:AAA', category: 'nico')
+    link_nico_to_tag!(nico, linked)
+
+    Tag.bot
+    Tag.tagme
+    Tag.no_deerjikist
+
+    stub_python([{
+      'code' => 'sm9',
+      'title' => 't',
+      'tags' => ['AAA'],
+      'uploaded_at' => '2026-01-01 12:34:56'
+    }])
+
+    allow(URI).to receive(:open).and_return(StringIO.new('<html></html>'))
+
+    expect {
+      run_rake_task('nico:sync')
+    }.to change(PostVersion, :count).by(1)
+
+    version = post.reload.post_versions.order(:version_no).last
+    expect(version.version_no).to eq(2)
+    expect(version.event_type).to eq('update')
+    expect(version.created_by_user).to be_nil
+    expect(version.tags).to eq(snapshot_tags(post.reload))
+  end
+
+  it '既存 post に差分が無いときは新しい version を作らない' do
+    nico = create_tag!('nico:AAA', category: 'nico')
+    no_deerjikist = create_tag!('ニジラー情報不詳', category: 'meta')
+
+    post = Post.create!(
+      title: 't',
+      url: 'https://www.nicovideo.jp/watch/sm9',
+      uploaded_user: nil,
+      original_created_from: Time.iso8601('2026-01-01T03:34:00Z'),
+      original_created_before: Time.iso8601('2026-01-01T03:35:00Z')
+    )
+
+    PostTag.create!(post: post, tag: nico)
+    PostTag.create!(post: post, tag: no_deerjikist)
+    create_post_version_for!(post)
+
+    stub_python([{
+      'code' => 'sm9',
+      'title' => 't',
+      'tags' => ['AAA'],
+      'uploaded_at' => '2026-01-01 12:34:56'
+    }])
+
+    allow(URI).to receive(:open).and_return(StringIO.new('<html></html>'))
+
+    expect {
+      run_rake_task('nico:sync')
+    }.not_to change(PostVersion, :count)
+
+    version = post.reload.post_versions.order(:version_no).last
+    expect(version.version_no).to eq(1)
+    expect(version.event_type).to eq('create')
+    expect(version.tags).to eq(snapshot_tags(post.reload))
+  end
+
+  it '新規 nico tag に nico tag version を作る' do
+    Tag.bot
+    Tag.tagme
+    Tag.niconico
+    Tag.video
+    Tag.no_deerjikist
+
+    stub_python([{
+      'code' => 'sm9',
+      'title' => 't',
+      'tags' => ['AAA'],
+      'uploaded_at' => '2026-01-01 12:34:56'
+    }])
+
+    allow(URI).to receive(:open).and_return(StringIO.new('<html></html>'))
+
+    expect {
+      run_rake_task('nico:sync')
+    }.to change(NicoTagVersion, :count).by(1)
+
+    nico_tag = Tag.joins(:tag_name).find_by!(tag_names: { name: 'nico:AAA' })
+    version = nico_tag.nico_tag_versions.order(:version_no).last
+
+    expect(version.version_no).to eq(1)
+    expect(version.event_type).to eq('create')
+    expect(version.name).to eq('nico:AAA')
+    expect(version.created_by_user).to be_nil
+  end
+
+  it '既存 post に version が無い場合は create snapshot を補う' do
+    post = Post.create!(
+      title: 'old',
+      url: 'https://www.nicovideo.jp/watch/sm9',
+      uploaded_user: nil
+    )
+
+    kept_general = create_tag!('spec_kept_without_version', category: 'general')
+    PostTag.create!(post: post, tag: kept_general)
+
+    Tag.bot
+    Tag.tagme
+    Tag.no_deerjikist
+
+    stub_python([{
+      'code' => 'sm9',
+      'title' => 'changed title',
+      'tags' => ['AAA'],
+      'uploaded_at' => '2026-01-01 12:34:56'
+    }])
+
+    allow(URI).to receive(:open).and_return(StringIO.new('<html></html>'))
+
+    expect {
+      run_rake_task('nico:sync')
+    }.to change { post.reload.post_versions.count }.by(1)
+
+    versions = post.reload.post_versions.order(:version_no)
+
+    expect(versions.map(&:event_type)).to eq(['create'])
+    expect(versions.first.title).to eq('changed title')
+    expect(versions.first.tags).to eq(snapshot_tags(post.reload))
+  end
+
+  it '既存 version がある post には update version を作る' do
+    post = Post.create!(
+      title: 'old',
+      url: 'https://www.nicovideo.jp/watch/sm9',
+      uploaded_user: nil
+    )
+
+    kept_general = create_tag!('spec_kept_with_version', category: 'general')
+    PostTag.create!(post: post, tag: kept_general)
+
+    PostVersionRecorder.record!(
+      post: post,
+      event_type: :create,
+      created_by_user: nil
+    )
+
+    Tag.bot
+    Tag.tagme
+    Tag.no_deerjikist
+
+    stub_python([{
+      'code' => 'sm9',
+      'title' => 'changed title',
+      'tags' => ['AAA'],
+      'uploaded_at' => '2026-01-01 12:34:56'
+    }])
+
+    allow(URI).to receive(:open).and_return(StringIO.new('<html></html>'))
+
+    expect {
+      run_rake_task('nico:sync')
+    }.to change { post.reload.post_versions.count }.by(1)
+
+    versions = post.reload.post_versions.order(:version_no)
+
+    expect(versions.map(&:event_type)).to eq(['create', 'update'])
+    expect(versions.first.title).to eq('old')
+    expect(versions.second.title).to eq('changed title')
+    expect(versions.second.tags).to eq(snapshot_tags(post.reload))
+  end
 end

backend/spec/tasks/post_sync_spec.rb

@@ -0,0 +1,25 @@
+require 'rails_helper'
+require 'rake'
+
+RSpec.describe 'post:sync' do
+  around do |example|
+    original_application = Rake.application
+    Rake.application = Rake::Application.new
+
+    Rake::Task.define_task(:environment)
+    load Rails.root.join('lib/tasks/sync_posts.rake')
+
+    example.run
+  ensure
+    Rake.application = original_application
+  end
+
+  it 'runs Youtube::Sync' do
+    sync = instance_double(Youtube::Sync)
+
+    expect(Youtube::Sync).to receive(:new).once.and_return(sync)
+    expect(sync).to receive(:sync!).once
+
+    Rake::Task['post:sync'].invoke
+  end
+end