368 行
17 KiB
Ruby
368 行
17 KiB
Ruby
require 'rails_helper'
|
|
require 'csv'
|
|
|
|
RSpec.describe 'Counts masked pivot contracts' do
|
|
let(:admin) { create(:user, :admin) }
|
|
let(:member) { create(:user, :member) }
|
|
let(:guest) { create(:user, :guest) }
|
|
let(:params) do
|
|
{ 'resource' => 'posts', 'definition' => 'history', 'mode' => 'summary',
|
|
'locale' => 'ja', 'execution_at' => '2025-01-01T00:00:00Z',
|
|
'timezone' => 'UTC', 'rows' => 'tags', 'cols' => 'event_type', 'sort' => '' }
|
|
end
|
|
let!(:tags) do
|
|
['A', 'B', 'C'].map do |name|
|
|
tag = create(:tag, primary_name: name)
|
|
TagVersion.create!(tag:, version_no: 1, event_type: 'create', name:,
|
|
category: 'general', aliases: '', parent_tag_ids: '',
|
|
names: { ja: { name:, script_code: 'Jpan', auto_generated: false, aliases: [] } },
|
|
created_at: Time.utc(2023))
|
|
tag
|
|
end
|
|
end
|
|
|
|
before do
|
|
[[0, 1], [0], [1, 2]].each_with_index do |indexes, index|
|
|
post = create(:post)
|
|
snapshot = indexes.map { { tag_id: tags[_1].id, version_no: 1, sections: [] } }
|
|
PostVersion.create!(post:, version_no: 1, event_type: 'create',
|
|
title: "hidden-title-#{ index }", url: post.url, tags: '', tags_json: snapshot,
|
|
parent_post_ids: '', created_by_user: member, created_at: Time.utc(2024, 1))
|
|
next if index == 2
|
|
|
|
PostVersion.create!(post:, version_no: 2, event_type: 'discard',
|
|
title: "private-discard-#{ index }", url: post.url, tags: '', tags_json: [],
|
|
parent_post_ids: '', created_by_user: member, created_at: Time.utc(2024, 2))
|
|
end
|
|
end
|
|
|
|
def result(user, extra = {})
|
|
HistoryAccess.set(user:) { CountsTableQuery.new(params.merge(extra)).call }
|
|
end
|
|
|
|
def grand(result)
|
|
result.fetch(:pivot_totals).find { _1[:row].empty? && _1[:column].empty? }.fetch(:count)
|
|
end
|
|
|
|
it 'preserves monthly name subtotals and grand totals across pages' do
|
|
settings = { 'resource' => 'tags', 'rows' => 'created_at:month name' }
|
|
complete = result(admin, settings)
|
|
expect(complete[:group_count]).to eq(3)
|
|
expect(grand(complete)).to eq(3)
|
|
(1..3).each do |page|
|
|
paged = result(admin, settings.merge('limit' => '1', 'page' => page.to_s))
|
|
expect(grand(paged)).to eq(3)
|
|
subtotal = paged[:pivot_totals].find do |cell|
|
|
cell[:row] == ['2023-01'] && cell[:column].empty?
|
|
end
|
|
headers = paged[:row_headers].select { _1[:kind] == 'subtotal' }
|
|
if page == 3
|
|
expect(headers.map { _1[:values] }).to eq([['2023-01']])
|
|
expect(subtotal).not_to be_nil
|
|
expect(subtotal[:count]).to eq(3)
|
|
else
|
|
expect(headers).to eq([])
|
|
expect(subtotal).to be_nil
|
|
end
|
|
expect(paged[:cells].sum { _1[:count] }).to eq(1)
|
|
expect(paged[:group_count]).to eq(3)
|
|
end
|
|
end
|
|
|
|
it 'counts one opaque collection per private version across pages' do
|
|
[nil, guest, member, admin].each do |user|
|
|
page = result(user)
|
|
expected = user == admin ? 5 : 6
|
|
expect(grand(page)).to eq(expected)
|
|
expect(page[:cells].sum { _1[:count] }).to eq(expected)
|
|
expect(page).not_to have_key(:excluded_count)
|
|
paged = result(user, 'limit' => '1')
|
|
expect(grand(paged)).to eq(expected)
|
|
expect(result(user, 'limit' => '1', 'page' => '2')[:group_count])
|
|
.to eq(page[:group_count])
|
|
end
|
|
public_page = result(nil)
|
|
hidden = public_page[:cells].select { _1[:values].first == CountsAxes::MASKED_VALUE }
|
|
expect(hidden.sum { _1[:count] }).to eq(4)
|
|
expect(public_page[:axis_labels]['a0']).not_to have_key("internal:#{ tags.first.id }")
|
|
expect(public_page.to_json).not_to include('hidden-title', 'private-discard')
|
|
end
|
|
|
|
it 'retains distinct membership when tags are not a row axis' do
|
|
[nil, admin].each do |user|
|
|
expect(grand(result(user, 'rows' => 'event_type', 'cols' => 'tags')))
|
|
.to eq(user == admin ? 3 : 5)
|
|
expect(result(user, 'rows' => '', 'cols' => '')[:cells].sole[:count]).to eq(5)
|
|
details = result(user, 'mode' => 'details', 'rows' => '', 'cols' => '')
|
|
expect(details[:count]).to eq(user == admin ? 5 : 1)
|
|
end
|
|
end
|
|
|
|
it 'uses changed-record membership for totals and hides changes to private predecessors' do
|
|
post = PostVersion.order(:id).last.post
|
|
PostVersion.create!(post:, version_no: 2, event_type: 'update', title: 'changed-public-title',
|
|
url: post.url, tags: '',
|
|
tags_json: [{ tag_id: tags.last.id, version_no: 1, sections: [] }],
|
|
parent_post_ids: '', created_at: Time.utc(2024, 3))
|
|
restored = PostVersion.order(:id).first.post
|
|
PostVersion.create!(post: restored, version_no: 3, event_type: 'restore',
|
|
title: 'restored-public-title', url: restored.url, tags: '',
|
|
tags_json: [{ tag_id: tags.first.id, version_no: 1, sections: [] }], parent_post_ids: '',
|
|
created_at: Time.utc(2024, 4))
|
|
[nil, admin].each do |user|
|
|
page = result(user, 'rows' => 'tags changed_field', 'cols' => 'event_type')
|
|
expect(grand(page)).to eq(page[:cells].sum { _1[:count] })
|
|
expect(page[:cells]).not_to be_empty
|
|
if user.nil?
|
|
expect(page[:cells].any? { _1[:values][1] == CountsAxes::MASKED_VALUE }).to be(true)
|
|
end
|
|
expect(page.to_json).not_to include('hidden-title', 'private-discard')
|
|
end
|
|
end
|
|
|
|
it 'counts distinct changed records when tags are not additive row tuples' do
|
|
[nil, admin].each do |user|
|
|
page = result(user, 'rows' => 'changed_field', 'cols' => 'event_type')
|
|
expect(grand(page)).to eq(user == admin ? 2 : 4)
|
|
if user.nil?
|
|
expect(page[:cells].map { _1[:values].first }.uniq).to eq([CountsAxes::MASKED_VALUE])
|
|
end
|
|
# Private empty collections contribute the same opaque tuple as populated ones.
|
|
combined = result(user, 'rows' => 'changed_field', 'cols' => 'tags')
|
|
expect(grand(combined)).to eq(user == admin ? 0 : 4)
|
|
end
|
|
end
|
|
|
|
it 'keeps NULL as a public data value rather than treating it as a rollup' do
|
|
post = create(:post)
|
|
PostVersion.create!(post:, version_no: 1, event_type: 'create', title: 'public bot',
|
|
url: post.url, tags: '', tags_json: [], parent_post_ids: '', created_at: Time.utc(2024, 5))
|
|
page = result(nil, 'rows' => 'user', 'cols' => 'event_type')
|
|
expect(page[:cells].select { _1[:values].first.nil? }.sum { _1[:count] }).to eq(1)
|
|
expect(grand(page)).to eq(6)
|
|
expect(page[:row_headers]).to include(hash_including(values: [nil], kind: 'data'))
|
|
end
|
|
|
|
it 'sorts public version numbers numerically including formerly hidden records' do
|
|
post = PostVersion.order(:id).last.post
|
|
[2, 10].each do |number|
|
|
PostVersion.create!(post:, version_no: number, event_type: 'update',
|
|
title: 'public numeric sort', url: post.url, tags: '', tags_json: [],
|
|
parent_post_ids: '', created_at: Time.utc(2024, 5))
|
|
end
|
|
page = result(nil, 'rows' => 'version_no', 'cols' => '')
|
|
values = page[:row_headers].select { _1[:kind] == 'data' }.map { _1[:values].first }
|
|
expect(values.map(&:to_i)).to eq([1, 2, 10])
|
|
end
|
|
|
|
it 'keeps public identity predicates and excludes private attributes' do
|
|
hidden_id = PostVersion.first.post_id.to_s
|
|
base = { 'rows' => '', 'cols' => '' }
|
|
condition = lambda do |field, operator, value|
|
|
{ 'conditions' => '', 'conditions.0.field' => field,
|
|
'conditions.0.operator' => operator, 'conditions.0.value' => value }
|
|
end
|
|
|
|
expect(result(nil, base.merge('resource_id' => hidden_id))[:cells].sole[:count]).to eq(2)
|
|
expect(result(nil, base.merge(condition.call('version_no', 'eq', '2')))[:cells]
|
|
.sole[:count]).to eq(2)
|
|
expect(result(nil, base.merge(condition.call('user', 'eq', member.id.to_s)))[:cells]
|
|
.sole[:count]).to eq(5)
|
|
expect(result(nil, base.merge(condition.call('title', 'eq', 'hidden-title-0')))[:cells]
|
|
.sole[:count]).to eq(0)
|
|
expect(result(nil, base.merge(condition.call('title', 'ne', 'hidden-title-0')))[:cells]
|
|
.sole[:count]).to eq(1)
|
|
expect(result(nil, base.merge(condition.call('title', 'eq', '********')))[:cells]
|
|
.sole[:count]).to eq(0)
|
|
expect(result(nil, base.merge(condition.call('video_ms', 'eq', '********')))[:cells]
|
|
.sole[:count]).to eq(0)
|
|
expect(result(nil, base.merge(condition.call('title', 'like', '%title%')))[:cells]
|
|
.sole[:count]).to eq(1)
|
|
expect(result(nil, base.merge(condition.call('title', 'like', '%')))[:cells]
|
|
.sole[:count]).to eq(1)
|
|
expect(result(nil, base.merge('tags' => 'C'))[:cells].sole[:count]).to eq(1)
|
|
expect(result(nil, base.merge('tags' => 'not:C'))[:cells].sole[:count]).to eq(0)
|
|
end
|
|
|
|
it 'retains public OR branches while rejecting private predicates on hidden rows' do
|
|
HistoryAccess.set(user: nil) do
|
|
population = CountsPopulation.new(params.merge('rows' => '', 'cols' => ''),
|
|
authorisation_flg: false)
|
|
condition = CountsCondition.new(population)
|
|
public_scope = condition.apply(population.scope,
|
|
{ 'field' => 'event_type', 'operator' => 'eq', 'value' => 'discard' })
|
|
private_scope = condition.apply(population.scope,
|
|
{ 'field' => 'title', 'operator' => 'ne', 'value' => 'unrelated' })
|
|
masked_scope = condition.apply(population.scope,
|
|
{ 'field' => 'title', 'operator' => 'eq', 'value' => '********' })
|
|
expect(public_scope.except(:select).count).to eq(2)
|
|
expect(public_scope.or(private_scope).except(:select).count).to eq(3)
|
|
expect(private_scope.or(public_scope).except(:select).count).to eq(3)
|
|
expect(public_scope.or(masked_scope).except(:select).count).to eq(2)
|
|
expect(public_scope.merge(private_scope).except(:select).count).to eq(0)
|
|
end
|
|
end
|
|
|
|
it 'excludes private collections from positive, negative, AND and OR tag searches' do
|
|
settings = { 'rows' => '', 'cols' => '' }
|
|
{ 'C' => 1, 'not:C' => 0, 'not:unknown' => 1, '********' => 0,
|
|
'not:********' => 1, 'not:C C' => 0, 'not:C type:or C' => 1 }.each do |value, count|
|
|
expect(result(nil, settings.merge('tags' => value))[:cells].sole[:count]).to eq(count)
|
|
end
|
|
end
|
|
|
|
it 'ignores empty numeric and interval bounds without restricting private history' do
|
|
settings = { 'rows' => '', 'cols' => '', 'conditions' => '' }
|
|
{ 'video_ms' => ['eq', 'ne', 'gt', 'ge', 'lt', 'le', 'range'],
|
|
'tags.sections' => ['range'] }.each do |field, operators|
|
|
operators.each do |operator|
|
|
condition = settings.merge('conditions.0.field' => field,
|
|
'conditions.0.operator' => operator)
|
|
empty = condition.merge('conditions.0.value' => '')
|
|
expect(result(nil, condition)[:cells].sole[:count]).to eq(5)
|
|
expect(result(nil, empty)[:cells].sole[:count]).to eq(5)
|
|
expect(result(nil, empty.merge('conditions.0.blank' => '0'))[:cells]
|
|
.sole[:count]).to eq(5)
|
|
if operator == 'range'
|
|
empty['conditions.0.end'] = ''
|
|
expect(result(nil, empty)[:cells].sole[:count]).to eq(5)
|
|
['conditions.0.value', 'conditions.0.end'].each do |key|
|
|
active = empty.merge(key => '100')
|
|
expect(result(nil, active)[:cells].sole[:count]).to eq(0)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
it 'keeps typed marker sets active after incompatible marker values are removed' do
|
|
settings = { 'rows' => '', 'cols' => '', 'conditions' => '',
|
|
'conditions.0.field' => 'video_ms', 'conditions.0.values' => '1',
|
|
'condition_values' => '', 'condition_values.0.condition' => '0',
|
|
'condition_values.0.value_type' => 'string',
|
|
'condition_values.0.value' => '********' }
|
|
['in', 'not_in'].each do |operator|
|
|
expected = operator == 'in' ? 0 : 1
|
|
condition = settings.merge('conditions.0.operator' => operator)
|
|
expect(result(nil, condition)[:cells].sole[:count]).to eq(expected)
|
|
end
|
|
end
|
|
|
|
it 'restricts active numeric comparisons and preserves empty selection semantics' do
|
|
settings = { 'rows' => '', 'cols' => '', 'conditions' => '',
|
|
'conditions.0.field' => 'video_ms' }
|
|
['eq', 'ne', 'gt', 'ge', 'lt', 'le', 'range'].each do |operator|
|
|
condition = settings.merge('conditions.0.operator' => operator,
|
|
'conditions.0.value' => '0')
|
|
condition['conditions.0.end'] = '100' if operator == 'range'
|
|
# The one public row is NULL; private NULLs and real values never match.
|
|
expected = operator == 'ne' ? 1 : 0
|
|
expect(result(nil, condition)[:cells].sole[:count]).to eq(expected)
|
|
end
|
|
['in', 'not_in'].each do |operator|
|
|
condition = settings.merge('conditions.0.operator' => operator,
|
|
'conditions.0.values' => '1', 'condition_values' => '')
|
|
expected = operator == 'not_in' ? 5 : 0
|
|
expect(result(nil, condition)[:cells].sole[:count]).to eq(expected)
|
|
end
|
|
blank = settings.merge('conditions.0.operator' => 'eq', 'conditions.0.blank' => '1')
|
|
expect(result(nil, blank)[:cells].sole[:count]).to eq(1)
|
|
end
|
|
|
|
it 'preserves empty tag sets and restricts active blank collection predicates' do
|
|
settings = { 'rows' => '', 'cols' => '', 'conditions' => '',
|
|
'conditions.0.field' => 'tags' }
|
|
['any', 'all', 'none'].each do |operator|
|
|
condition = settings.merge('conditions.0.operator' => operator,
|
|
'conditions.0.values' => '1', 'condition_values' => '')
|
|
expected = operator == 'any' ? 0 : 5
|
|
expect(result(nil, condition)[:cells].sole[:count]).to eq(expected)
|
|
end
|
|
blank = settings.merge('conditions.0.operator' => 'eq', 'conditions.0.blank' => '1')
|
|
expect(result(nil, blank)[:cells].sole[:count]).to eq(0)
|
|
end
|
|
|
|
it 'rejects server-only coordinates in column order' do
|
|
probes = [
|
|
{ 'cols' => 'tags', 'column_order' => '', 'column_order.0.value_type' => 'string',
|
|
'column_order.0.value' => CountsAxes::MASKED_VALUE }]
|
|
HistoryAccess.set(user: nil) do
|
|
probes.each do |probe|
|
|
expect { CountsTableQuery.new(params.merge(probe)).call }
|
|
.to raise_error(CountsAxes::PrivateCondition)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
it 'keeps private collection and change counts independent of stored elements' do
|
|
settings = [
|
|
{ 'rows' => 'tags', 'cols' => 'changed_field' },
|
|
{ 'rows' => 'changed_field tags', 'cols' => '' }]
|
|
original = settings.map { result(nil, _1) }
|
|
snapshot = tags.map do |tag|
|
|
{ tag_id: tag.id, version_no: 1, sections: [] }
|
|
end
|
|
hidden_posts = PostVersion.where(event_type: 'discard').pluck(:post_id)
|
|
PostVersion.where(post_id: hidden_posts).update_all(
|
|
title: 'same hidden value', tags_json: snapshot)
|
|
expect(settings.map { result(nil, _1) }).to eq(original)
|
|
end
|
|
|
|
it 'excludes private tag and change coordinates from drill conditions' do
|
|
['tags', 'changed_field'].each do |field|
|
|
settings = { 'rows' => field, 'cols' => '' }
|
|
page = result(nil, settings)
|
|
cell = page[:cells].find { _1[:values] == [CountsAxes::MASKED_VALUE] }
|
|
expect(cell[:count]).to eq(4)
|
|
[CountsAxes::MASKED_VALUE, CountsAxes::MASKED_TEXT].each do |value|
|
|
drill = { 'drill' => '', 'drill.0.field' => field,
|
|
'drill.0.value_type' => 'string', 'drill.0.value' => value }
|
|
expect(result(nil, settings.merge(drill))[:cells]).to be_empty
|
|
details = result(nil, settings.merge(drill).merge('mode' => 'details'))
|
|
expect(details[:versions]).to be_empty
|
|
condition = { 'conditions' => '', 'conditions.0.field' => field,
|
|
'conditions.0.operator' => 'axis_eq',
|
|
'conditions.0.value_type' => 'string', 'conditions.0.value' => value }
|
|
expect(result(nil, settings.merge(condition))[:cells]).to be_empty
|
|
end
|
|
end
|
|
end
|
|
|
|
it 'rejects real private tag and change coordinates for non-admin users' do
|
|
[nil, guest, member].each do |user|
|
|
{ 'tags' => "internal:#{ tags.first.id }", 'changed_field' => 'title' }.each do
|
|
|field, value|
|
|
settings = { 'rows' => '', 'cols' => '', 'drill' => '',
|
|
'drill.0.field' => field, 'drill.0.value_type' => 'string',
|
|
'drill.0.value' => value }
|
|
expect(result(user, settings)[:cells].sole[:count]).to eq(0)
|
|
expect(result(admin, settings)[:cells].sole[:count]).to be > 0
|
|
end
|
|
end
|
|
end
|
|
|
|
it 'keeps public column sorting usable while guessed private coordinates match nothing' do
|
|
first = result(nil, 'rows' => 'event_type', 'cols' => 'tags')
|
|
probe = result(nil, 'rows' => 'event_type', 'cols' => 'tags',
|
|
'column_order' => '', 'column_order.0.value_type' => 'string',
|
|
'column_order.0.value' => "internal:#{ tags.first.id }")
|
|
expect(probe[:column_values]).to eq(first[:column_values])
|
|
expect(probe[:cells]).to eq(first[:cells])
|
|
expect(probe[:column_values_editable]).to be(false)
|
|
expect(probe.to_json).not_to include("internal:#{ tags.first.id }")
|
|
end
|
|
|
|
it 'exports masked coordinates and safe CSV labels from the same pivot' do
|
|
HistoryAccess.set(user: nil) do
|
|
payload = params.merge('format' => 'json')
|
|
json = JSON.parse(CountsTableExport.new(payload).body.to_a.join)
|
|
expect(json['data'].sum { _1['kind'] == 'data' ? _1['count'] : 0 }).to eq(6)
|
|
expect(json.to_json).not_to include('hidden-title', 'private-discard')
|
|
csv = CountsTableExport.new(payload.merge('format' => 'csv')).body.to_a.join
|
|
expect(csv).to include('********')
|
|
expect(csv).not_to include(CountsAxes::MASKED_VALUE, 'hidden-title', 'private-discard')
|
|
end
|
|
end
|
|
end
|