Merge branch 'main' into feature/479

このコミットが含まれているのは:
2026-11-23 03:58:34 +09:00
コミット 570846db67
19個のファイルの変更、455行の追加、139行の削除
+22 -4
ファイルの表示
@@ -14,22 +14,40 @@ RSpec.describe 'History boundaries shared with Counts', type: :request do
end
end
it 'denies the same discarded description through Counts, the facade and the ordinary API' do
it 'keeps discarded history private while exposing the current description' do
get '/counts/query', params: { resource: 'tag_descriptions', definition: 'history',
mode: 'details', locale: 'ja', execution_at: '2025-01-01T00:00:00Z' }
expect(response).to have_http_status(:ok)
expect(response.parsed_body).to include('count' => 0, 'output_count' => 2,
'excluded_count' => 2, 'versions' => [])
["/wiki/#{ description.id }", "/tags/#{ tag.id }/description"].each do |path|
paths = [
"/wiki/#{ description.id }", '/wiki/title/description%20tag',
"/tags/#{ tag.id }/description"]
paths.each do |path|
get path, params: { locale: 'ja' }
expect(response).to have_http_status(:not_found)
expect(response.body).not_to include('private body')
expect(response).to have_http_status(:ok)
expect(response.parsed_body.fetch('body')).to eq(description.body)
end
get '/sitemap_entries/descriptions', params: { locale: 'ja' }
expect(response).to have_http_status(:ok)
expect(response.parsed_body['ids']).not_to include(description.id)
end
it 'omits private revision references and rejects history and diff requests' do
get "/wiki/#{ description.id }", params: { locale: 'ja' }
expect(response).to have_http_status(:ok)
expect(response.parsed_body).to include(
'revision_id' => nil, 'pred' => nil, 'succ' => nil,
'updated_at' => description.updated_at.iso8601(3))
version = TagDescriptionVersion.find_by!(
tag_id: tag.id, language_code: 'ja', version_no: 2)
get "/wiki/#{ description.id }", params: { locale: 'ja', version: version.id }
expect(response).to have_http_status(:not_found)
get "/wiki/#{ description.id }/diff", params: { locale: 'ja' }
expect(response).to have_http_status(:not_found)
end
it 'permits the server-authenticated administrator to read the discarded description' do
sign_in_as(create(:user, :admin))
get "/tags/#{ tag.id }/description", params: { locale: 'ja' }
+50
ファイルの表示
@@ -3,6 +3,56 @@ require 'rails_helper'
RSpec.describe 'NicoTags', type: :request do
describe 'GET /tags/nico' do
[:name, :linked_tag].each do |field|
context "when #{ field } contains wildcards" do
let!(:search_tags) do
names = ['wild%end', 'wild_end', 'wildXend', 'wildABend', 'wild%_end']
names.map.with_index do |name, index|
if field == :name
create(:external_tag, name:)
else
destination = create(:tag, primary_name: name)
external = create(:external_tag, name: "wild-linked-#{ index }")
NicoTagRelation.create!(nico_tag: external, tag: destination)
external
end
end
end
{
'%' => [0, 4],
'_' => [1, 4],
'wild%end' => [0],
'wild_end' => [1],
'wild*end' => [0, 1, 2, 3, 4],
'wild?end' => [0, 1, 2],
'wild??end' => [3, 4],
'wild%*end' => [0, 4],
'wild_?nd' => [1],
'wild%?end' => [4] }.each do |query, indices|
it "filters #{ field } with #{ query.inspect }" do
get '/tags/nico', params: { field => query }
expected_ids = indices.map { |index| search_tags[index].id }
expect(response).to have_http_status(:ok)
expect(json.fetch('tags').pluck('id')).to match_array(expected_ids)
expect(json.fetch('count')).to eq(expected_ids.size)
end
end
end
end
it 'supports wildcards in qualified external names' do
external = create(:external_tag, name: 'qualified_end')
create(:external_tag, name: 'qualifiedABend')
get '/tags/nico', params: { name: 'nico:qualified?end' }
expect(response).to have_http_status(:ok)
expect(json.fetch('tags').pluck('id')).to eq([external.id])
expect(json.fetch('count')).to eq(1)
end
it 'returns the legacy Tag-compatible external fields' do
external = create(:external_tag, name: 'legacy_external', post_count: 3)
+8 -10
ファイルの表示
@@ -69,40 +69,38 @@ RSpec.describe 'Post history privacy', type: :request do
sign_in_as(create(:user, role.to_sym)) unless role == 'anonymous'
end
it 'uses only authorised history timestamps for display' do
it 'uses the latest version timestamp for display regardless of role' do
get '/posts'
expect(response).to have_http_status(:ok)
row = response.parsed_body.fetch('posts').find { _1.fetch('id') == post_record.id }
expected = origin + (role == 'admin' ? 4 : 3).days
expected = origin + 4.days
expect(Time.zone.parse(row.fetch('updated_at'))).to eq(expected)
end
it 'uses the same visibility for date bounds and count' do
it 'uses the latest version timestamp for date bounds and count regardless of role' do
get '/posts', params: { updated_from: (origin + 4.days).iso8601,
updated_to: (origin + 4.days).iso8601 }
expect(response).to have_http_status(:ok)
ids = response.parsed_body.fetch('posts').pluck('id')
expect(ids).to eq(role == 'admin' ? [post_record.id] : [])
expect(ids).to eq([post_record.id])
expect(response.parsed_body.fetch('count')).to eq(ids.length)
end
it 'sorts using authorised timestamps in both directions' do
it 'sorts using the latest version timestamps in both directions regardless of role' do
['asc', 'desc'].each do |direction|
get '/posts', params: { order: "updated_at:#{ direction }" }
expect(response).to have_http_status(:ok)
expected = role == 'admin' ? [other_post.id, post_record.id] :
[post_record.id, other_post.id]
expected = [other_post.id, post_record.id]
expected.reverse! if direction == 'desc'
expect(response.parsed_body.fetch('posts').pluck('id')).to eq(expected)
end
end
it 'applies authorised timestamp ordering before pagination' do
it 'applies latest version timestamp ordering before pagination regardless of role' do
get '/posts', params: { order: 'updated_at:desc', limit: 1 }
expect(response).to have_http_status(:ok)
expected = role == 'admin' ? post_record.id : other_post.id
expect(response.parsed_body.fetch('posts').pluck('id')).to eq([expected])
expect(response.parsed_body.fetch('posts').pluck('id')).to eq([post_record.id])
expect(response.parsed_body.fetch('count')).to eq(2)
end
+93
ファイルの表示
@@ -206,6 +206,25 @@ RSpec.describe 'Posts API', type: :request do
end
context 'when q is provided' do
['SPEC_TAG', 'SpEc_TaG', 'spec_tág', 'MANKO', 'MaNkO', 'mánko'].each do |name|
it "matches #{ name } using database collation" do
get '/posts', params: { locale: 'ja', tags: name }
expect(response).to have_http_status(:ok)
expect(json.fetch('count')).to eq(2)
expect(json.fetch('posts').map { _1.fetch('id') })
.to contain_exactly(post_record.id, hit_post.id)
end
it "excludes #{ name } using database collation" do
get '/posts', params: { locale: 'ja', tags: "not:#{ name }" }
expect(response).to have_http_status(:ok)
expect(json.fetch('count')).to eq(1)
expect(json.fetch('posts').map { _1.fetch('id') }).to eq([miss_post.id])
end
end
it 'filters posts by q (hit case)' do
get '/posts', params: { tags: 'spec_tag' }
@@ -266,6 +285,26 @@ RSpec.describe 'Posts API', type: :request do
PostExternalTag.create!(post: miss_post, external_tag:)
end
['NICO:SEARCH_EXTERNAL', 'NiCo:SeArCh_ExTeRnAl', 'nico:séarch_external'].each do |name|
it "matches #{ name } using database collation" do
get '/posts', params: { locale: 'ja', tags: name }
expect(response).to have_http_status(:ok)
expect(json.fetch('count')).to eq(2)
expect(json.fetch('posts').map { _1.fetch('id') })
.to contain_exactly(miss_post.id, both_post.id)
end
it "excludes #{ name } using database collation" do
get '/posts', params: { locale: 'ja', tags: "not:#{ name }" }
expect(response).to have_http_status(:ok)
expect(json.fetch('count')).to eq(2)
expect(json.fetch('posts').map { _1.fetch('id') })
.to contain_exactly(post_record.id, hit_post.id)
end
end
it 'keeps internal name searches independent of colliding external ids' do
get '/posts', params: { tags: primary_tag_name_for(tag, 'ja').name }
@@ -516,6 +555,45 @@ RSpec.describe 'Posts API', type: :request do
end
end
[:title, :url].each do |field|
context "when #{field} contains wildcards" do
let!(:search_posts) do
values = [
'needle%25end', 'needleX25end', 'needle_end',
'needleXend', 'needleABend', 'needle%25_end']
values.map.with_index do |value, index|
Post.create!(uploaded_user: user,
title: field == :title ? "prefix #{value} suffix" : 'url search post',
url: field == :url ? "https://example.com/prefix-#{value}-suffix" :
"https://example.com/title-search-#{index}")
end
end
{
'%' => [0, 5],
'_' => [2, 5],
'needle%25end' => [0],
'needle_end' => [2],
'needle*end' => [0, 1, 2, 3, 4, 5],
'needle?end' => [2, 3],
'needle??end' => [4],
'needle%*end' => [0, 5],
'needle_?nd' => [2],
'needle%25_end' => [5],
'needle%25_*end' => [5]
}.each do |query, expected_indices|
it "matches #{query.inspect} using only * and ? as wildcards" do
get '/posts', params: { field => query }
expect(response).to have_http_status(:ok)
expected_ids = expected_indices.map { |i| search_posts[i].id }
expect(json.fetch('posts').map { |p| p['id'] }).to match_array(expected_ids)
expect(json.fetch('count')).to eq(expected_ids.size)
end
end
end
end
context 'when created_from/created_to are provided' do
let(:t_created_hit) { Time.zone.local(2010, 1, 5, 12, 0, 0) }
let(:t_created_miss) { Time.zone.local(2012, 1, 5, 12, 0, 0) }
@@ -2559,6 +2637,21 @@ RSpec.describe 'Posts API', type: :request do
expect(user.reload.viewed?(post_record)).to be(true)
end
it '204 and keeps one view on repeated requests' do
sign_in_as(user)
expect {
post "/posts/#{ post_record.id }/viewed"
}.to change(UserPostView, :count).by(1)
expect(response).to have_http_status(:no_content)
expect {
post "/posts/#{ post_record.id }/viewed"
}.not_to change(UserPostView, :count)
expect(response).to have_http_status(:no_content)
expect(user.reload.viewed?(post_record)).to be(true)
end
end
describe 'DELETE /posts/:id/viewed' do
+4 -2
ファイルの表示
@@ -62,10 +62,12 @@ RSpec.describe 'Tag description Wiki compatibility', type: :request do
expect(response).to have_http_status(:not_found)
end
it 'does not fall back when the new current revision is missing' do
it 'reads current content when the corresponding revision is missing' do
TagDescriptionVersion.where(id: versions.last.id).delete_all
without_legacy_reads { get "/wiki/#{ description.id }" }
expect(response).to have_http_status(:not_found)
expect(response).to have_http_status(:ok)
expect(json).to include('body' => description.body,
'revision_id' => nil, 'pred' => nil, 'succ' => nil)
end
end
+24
ファイルの表示
@@ -42,6 +42,30 @@ RSpec.describe 'Tag group Wiki facade reads', type: :request do
'updated_at' => first_revision.created_at.iso8601(3))
end
it 'reads current structure while keeping discarded history private' do
TagGroupVersion.where(id: last_revision.id).update_all(event_type: 'discard')
without_group_legacy_reads { get path }
expect(response).to have_http_status(:ok)
expect(json).to include(
'body' => '- 新タグ', 'revision_id' => nil, 'pred' => nil, 'succ' => nil,
'updated_at' => page.updated_at.iso8601(3))
get path, params: { version: last_revision.id }
expect(response).to have_http_status(:not_found)
get "/wiki/#{ page.id }/diff"
expect(response).to have_http_status(:not_found)
end
it 'reads current structure when the corresponding revision is missing' do
TagGroupVersion.where(id: last_revision.id).delete_all
without_group_legacy_reads { get path }
expect(response).to have_http_status(:ok)
expect(json).to include(
'body' => '- 新タグ', 'revision_id' => nil, 'pred' => nil, 'succ' => nil)
end
it 'checks existence without consulting migrated Wiki tables' do
without_group_legacy_reads { get "#{ path }/exists" }
expect(response).to have_http_status(:no_content)
+119 -1
ファイルの表示
@@ -39,6 +39,46 @@ RSpec.describe 'Tags API', type: :request do
end
describe 'GET /tags' do
context 'when the name contains wildcards' do
let!(:tn) { create(:tag_name, name: 'background-tag') }
let(:names) do
['wild%end', 'wild_end', 'wildXend', 'wildABend', 'wild%_end']
end
before do
names.each do |name|
create(:tag, primary_name: name)
create(:external_tag, name:)
end
end
{
'%' => [0, 4],
'_' => [1, 4],
'wild%end' => [0],
'wild_end' => [1],
'wild*end' => [0, 1, 2, 3, 4],
'wild?end' => [0, 1, 2],
'wild??end' => [3, 4],
'wild%*end' => [0, 4],
'wild_?nd' => [1],
'wild%?end' => [4],
'nico:wild?end' => [0, 1, 2] }.each do |query, indices|
it "filters internal and external names with #{ query.inspect }" do
get '/tags', params: { name: query }
expected_names = indices.flat_map do |index|
name = names[index]
query.start_with?('nico:') ? ["nico:#{ name }"] : [name, "nico:#{ name }"]
end
expect(response).to have_http_status(:ok)
expect(response_names).to match_array(expected_names)
expect(json.fetch('count')).to eq(expected_names.size)
end
end
end
it 'serialises descriptions and parents without loading legacy Wiki pages' do
TagDescription.create!(tag:, language_code: 'ja', body: '', version_no: 1)
TagDescription.create!(tag: tag2, language_code: 'ja', body: '', version_no: 1)
@@ -439,6 +479,41 @@ RSpec.describe 'Tags API', type: :request do
end
describe 'GET /tags/autocomplete' do
context 'when q contains wildcards' do
let(:names) { ['wildend', 'wildXend', 'wildABend', 'otherwildXend'] }
before do
names.each_with_index do |name, index|
create(:tag, primary_name: name, post_count: 1)
alias_target = create(:tag, primary_name: "target_#{ index }", post_count: 1)
create(:tag_name, :alias, name: "#{ name }_alias", tag: alias_target)
create(:external_tag, name:, post_count: 1)
end
end
{
'wild*end' => [0, 1, 2, 3],
'wild?end' => [1, 3],
'not:wild?end' => [1, 3],
'nico:wild?end' => [1] }.each do |query, indices|
it "matches primary, alias, and external names with #{ query.inspect }" do
get '/tags/autocomplete', params: { q: query }
expected_names = indices.flat_map do |index|
name = names[index]
query.start_with?('nico:') ? ["nico:#{ name }"] :
[name, "target_#{ index }", "nico:#{ name }"]
end
expect(response).to have_http_status(:ok)
expect(json.map { |row| row.fetch('name') }).to match_array(expected_names)
unless query.start_with?('nico:')
row = json.find { |item| item.fetch('name') == "target_#{ indices.first }" }
expect(row.fetch('matched_alias')).to eq("#{ names[indices.first] }_alias")
end
end
end
end
it 'combines internal and external matches without conflating equal ids' do
internal = create(:tag, category: :general, primary_name: 'mixed_internal', post_count: 2)
external = create(:external_tag, id: internal.id,
@@ -482,6 +557,7 @@ RSpec.describe 'Tags API', type: :request do
create(:tag, category: :general, primary_name: name, post_count: 1)
create(:external_tag, name:, post_count: 1)
end
create(:external_tag, name: 'suffix_combined', post_count: 100)
get '/tags/autocomplete', params: { q: 'combined' }
@@ -490,6 +566,40 @@ RSpec.describe 'Tags API', type: :request do
expect(json.map { |row| row.fetch('name') }).to eq(expected.first(20))
end
it 'appends primary, alias, and external partial matches without duplicate resources' do
prefix = create(:tag, primary_name: 'tail', post_count: 1)
create(:tag_name, :alias, name: 'tail_alias', tag: prefix)
create(:tag_name, :alias, name: 'alias_tail', tag: prefix)
create(:tag, primary_name: 'primary_tail', post_count: 4)
alias_target = create(:tag, primary_name: 'alias_target', post_count: 3)
create(:tag_name, :alias, name: 'middle_tail_alias', tag: alias_target)
external = create(:external_tag, id: prefix.id, name: 'external_tail', post_count: 5)
create(:tag, primary_name: 'middle_tail_only', post_count: 100)
create(:external_tag, name: 'middle_tail_only', post_count: 100)
get '/tags/autocomplete', params: { q: 'tail' }
expect(response).to have_http_status(:ok)
expect(json.map { |row| row.fetch('name') }).to eq(
['tail', 'middle_tail_only', 'nico:middle_tail_only',
'nico:external_tail', 'primary_tail', 'alias_target'])
expect(json.first.fetch('matched_alias')).to eq('tail_alias')
expect(json.last.fetch('matched_alias')).to eq('middle_tail_alias')
expect(json[3]).to include('id' => external.id, 'category' => 'nico')
end
it 'fills only the remaining places with partial matches' do
names = 19.times.map { |number| "capacity_#{ number.to_s.rjust(2, '0') }" }
names.each { create(:tag, primary_name: _1, post_count: 1) }
create(:tag, primary_name: 'first_capacity_match', post_count: 3)
create(:external_tag, name: 'second_capacity_match', post_count: 2)
get '/tags/autocomplete', params: { q: 'capacity' }
expect(response).to have_http_status(:ok)
expect(json.map { |row| row.fetch('name') }).to eq(names + ['first_capacity_match'])
end
it 'excludes external tags but preserves internal alias matches when nico is false' do
internal = create(:tag, category: :general, primary_name: 'switch_internal', post_count: 1)
alias_target = create(:tag, category: :general, primary_name: 'alias_target', post_count: 1)
@@ -518,12 +628,20 @@ RSpec.describe 'Tags API', type: :request do
create(:external_tag, name: literal, post_count: 1)
create(:tag, category: :general, primary_name: 'literalXmatch', post_count: 2)
create(:external_tag, name: 'literalXmatch', post_count: 2)
suffix = "suffix_literal#{ wildcard }"
create(:tag, primary_name: suffix, post_count: 1)
suffix_alias = create(:tag, primary_name: 'suffix_alias_target', post_count: 1)
create(:tag_name, :alias, name: "alias_#{ suffix }", tag: suffix_alias)
create(:external_tag, name: suffix, post_count: 1)
create(:tag, primary_name: 'suffix_literalX', post_count: 2)
create(:external_tag, name: 'suffix_literalX', post_count: 2)
get '/tags/autocomplete', params: { q: "literal#{ wildcard }" }
expect(json.map { |row| row.fetch('name') })
.to contain_exactly(
literal, primary_tag_name_for(alias_target, 'ja').name, "nico:#{ literal }")
literal, primary_tag_name_for(alias_target, 'ja').name, "nico:#{ literal }",
suffix, 'suffix_alias_target', "nico:#{ suffix }")
end
end