Files
quality_analyse/verification/test_source_column_protocol.py
T
lyun ff7bbe3e46 同步:完善质量分析工作台并更新主题字体
同步已上线的智能分析执行协议、来源查询、图表报告与管理页面配套代码。
补齐数据库迁移、运行依赖和回归测试,保留原有指标计算口径。
统一午夜黑及其他主题的控件细节、中文和业务数字字体。
排除本地业务数据、凭据、预览、发布与验收产物。

验证:生产构建通过,320项前端回归通过;本轮仅同步Git,不再次部署。
2026-10-30 22:40:58 +08:00

502 lines
32 KiB
Python

from __future__ import annotations
import json
import sys
import tempfile
import threading
import unittest
from pathlib import Path
from urllib.parse import parse_qs, urlsplit
from unittest.mock import patch
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'scripts'))
sys.path.insert(0, str(ROOT / 'verification'))
from nao_agent_task import TaskUnavailable, bind_task, normalize_task
from nao_agent_task import plan_task
from nao_protocol_execution import execute
from nao_quality_tools import QualityToolError, QualityTools
from nao_query_contract import bind_query
from test_nao_agent_task import task_value
from test_nao_quality_tools import FakeApi, RELEASE
def source_field(key, label, black, bright, stages=('black', 'bright')):
return {'key': key, 'label': label, 'columns': {'black': black, 'bright': bright},
'stages': list(stages), 'type': 'source_value',
'operators': ['in', 'not_in', 'is_empty', 'not_empty']}
SOURCE_FIELDS = [
source_field('product', '产品', '黑片产品', '亮片产品'),
source_field('department', '产业部', '黑片产业部', '亮片产业部'),
source_field('group', '业务分组', '黑片分组', '亮片分组'),
source_field('projectGroup', '项目分组', '黑片项目分组', '亮片项目分组'),
source_field('src_hash', '来源哈希', '黑片行哈希', '亮片行哈希'),
source_field('batchNumber', '批号 | 代码', '黑片批次号', '亮片批号'),
source_field('customerSpec', '客户规格', '客户规格编码', '检包规格'),
source_field('dispatchOrder', '委托单', '黑片委托单号', '亮片工单委托'),
source_field('blackOnlyCode', '黑片专用代码', '黑片专用列', '', ('black',)),
]
CATALOG = {'sourceFields': SOURCE_FIELDS, 'departments': [], 'groups': []}
AUTHORITY = {'attemptId': 'attempt-1', 'sessionId': 'session-1', 'turnId': 'turn-1',
'revision': 4, 'executionId': 'execution-1'}
RULES = [
{'field': 'batchNumber', 'stages': ['black'], 'operator': 'in', 'values': ['0012', 'A|B']},
{'field': 'customerSpec', 'stages': ['bright'], 'operator': 'not_in', 'values': ['xY']},
{'field': 'dispatchOrder', 'stages': ['black', 'bright'], 'operator': 'not_empty'},
]
def protocol_task(**changes):
value = {**task_value(kind='metrics', dimensions=[], stages=['black', 'bright'], fields=['rate'],
period={'year': 2026, 'month': 3}, comparisonRequired=False,
trendRequired=False, columnFilters=RULES), **changes}
return normalize_task(value, '查询本期正式指标', {'_protocol': {'version': 1}, '_businessCatalog': CATALOG})
class EchoColumnApi(FakeApi):
def __init__(self, *, echo='flat'):
super().__init__()
self.echo = echo
def call(self, path, payload=None, method=None):
result = super().call(path, payload, method)
parsed = urlsplit(path)
if parsed.path == '/api/analysis/tools/catalog':
result['sourceFields'] = SOURCE_FIELDS
if parsed.path == '/api/metrics' and 'columnFilters' in parse_qs(parsed.query):
requested = json.loads(parse_qs(parsed.query)['columnFilters'][0])
if self.echo == 'request':
result['context']['filters'] = {'columnFilters': requested}
elif self.echo == 'flat':
result['context']['columnFilters'] = requested
elif self.echo == 'mismatch':
result['context']['filters'] = {'columnFilters': []}
return result
class SourceColumnProtocolTests(unittest.TestCase):
def test_final_answer_selector_preserves_the_confirmed_column_scope(self):
from nao_evidence_finalizer import _agent_task_summary
task=protocol_task()
summary=_agent_task_summary(bind_task({'releaseId':RELEASE},task))
self.assertEqual(summary['filters']['columnFilters'],RULES)
self.assertEqual(summary['sourceFieldLabels'],task['sourceFieldLabels'])
def test_member_intrinsic_defaults_do_not_trigger_expensive_replanning(self):
value=task_value(kind='members',dimensions=[],fields=[],stages=['black'],memberFields=['dispatchOrder'],columnFilters=[],trendRequired=False)
for key in ('freshQuery','verifySource','fullDetails','responseStyle','historyMode','periodCoverage'):
value.pop(key,None)
task=normalize_task(value,'列出本期黑片委托单',{'_protocol':{'version':1},'_businessCatalog':CATALOG})
self.assertTrue(task['freshQuery']);self.assertFalse(task['verifySource']);self.assertFalse(task['fullDetails'])
self.assertEqual(task['responseStyle'],'standard')
def test_members_allow_authorized_canonical_dimension_projection_only(self):
canonical_product = {**SOURCE_FIELDS[0], 'type': 'dimension'}
catalog = {'sourceFields': [canonical_product, *SOURCE_FIELDS[1:]], 'departments': [], 'groups': []}
task = normalize_task(task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
period={'year': 2026, 'month': 3}, comparisonRequired=False, trendRequired=False,
memberFields=['product'], columnFilters=[]), '列出客户规格清单',
{'_protocol': {'version': 1}, '_businessCatalog': catalog})
self.assertEqual(task['memberFields'], ['product'])
self.assertEqual(task['sourceFieldLabels'], {'product': '产品'})
# The same canonical directory entry is a member projection, not an
# authorized source_value filter rule.
with self.assertRaisesRegex(TaskUnavailable, '不是受支持的原表文本字段'):
normalize_task(task_value(kind='metrics', dimensions=[], stages=['black'], fields=['rate'],
period={'year': 2026, 'month': 3}, comparisonRequired=False, trendRequired=False,
columnFilters=[{'field': 'product', 'stages': ['black'], 'operator': 'in', 'values': ['18X15X4']}]),
'按产品筛选指标', {'_protocol': {'version': 1}, '_businessCatalog': catalog})
def test_column_filter_value_length_matches_backend_256_character_limit(self):
rule = {'field': 'batchNumber', 'stages': ['black'], 'operator': 'in', 'values': ['X' * 256]}
task = protocol_task(columnFilters=[rule])
self.assertEqual(task['filters']['columnFilters'][0]['values'], ['X' * 256])
with self.assertRaisesRegex(TaskUnavailable, '不超过256字符'):
protocol_task(columnFilters=[{**rule, 'values': ['X' * 257]}])
def test_protocol_presentation_enums_default_consistently_when_omitted_or_null(self):
base = task_value(kind='metrics', dimensions=[], stages=['black'], fields=['rate'],
period={'year': 2026, 'month': 3}, comparisonRequired=False,
trendRequired=False, columnFilters=[])
base.pop('responseStyle')
base['visualPreference'] = None
base['historyMode'] = None
base['periodCoverage'] = None
task = normalize_task(base, '查询本期正式指标', {
'_protocol': {'version': 1}, '_businessCatalog': CATALOG})
self.assertEqual(task['responseStyle'], 'standard')
self.assertEqual(task['visualPreference'], 'auto')
self.assertEqual(task['historyMode'], 'none')
self.assertEqual(task['periodCoverage'], 'complete')
trend = normalize_task({**base, 'trendRequired': True}, '查询本期正式指标', {
'_protocol': {'version': 1}, '_businessCatalog': CATALOG})
self.assertEqual(trend['periodCoverage'], 'available')
for invalid in ('', 'verbose', False):
with self.subTest(invalid=invalid), self.assertRaises(TaskUnavailable):
normalize_task({**base, 'responseStyle': invalid}, '查询本期正式指标', {
'_protocol': {'version': 1}, '_businessCatalog': CATALOG})
with self.assertRaises(TaskUnavailable):
normalize_task({**base, 'historyMode': ''}, '查询本期正式指标', {
'_protocol': {'version': 1}, '_businessCatalog': CATALOG})
with self.assertRaises(TaskUnavailable):
normalize_task({**base, 'periodCoverage': ''}, '查询本期正式指标', {
'_protocol': {'version': 1}, '_businessCatalog': CATALOG})
def test_protocol_short_prompt_lists_required_fields_and_enum_defaults(self):
# Capture the planner request without invoking a live model.
with patch('nao_agent_task._model_json', side_effect=[task_value(kind='metrics', dimensions=[], stages=['black'], fields=['rate'],
period={'year': 2026, 'month': 3}, comparisonRequired=False,
trendRequired=False, columnFilters=[]),
{'aligned': True, 'requiresEvidence': True, 'requiresSourceVerification': False,
'requiresAllSourceRows': False, 'requiresTrend': False,
'requiresComparison': False, 'columnFiltersAligned': True}]) as model_call:
plan_task(base_url='https://offline.invalid/v1', api_key='synthetic', model='m',
question='查询本期正式指标',
context={'_protocol': {'version': 1}, '_businessCatalog': CATALOG},
cancel_event=threading.Event())
prompt = model_call.call_args_list[0].kwargs['system']
self.assertIn('responseStyle(brief/standard/detailed,可省略或null,默认standard)', prompt)
self.assertIn('historyMode(none/last/all,可省略或null,默认none)', prompt)
self.assertIn('periodCoverage(available/complete,可省略或null', prompt)
self.assertIn('freshQuery(bool)', prompt)
self.assertIn('needsClarification(bool)', prompt)
def test_three_arbitrary_source_keys_keep_literal_values_and_stage_scopes(self):
task = protocol_task()
self.assertNotIn('columnFilters', task)
self.assertEqual(task['filters']['columnFilters'], RULES)
self.assertEqual(task['sourceFieldLabels'], {
'batchNumber': '批号 | 代码', 'customerSpec': '客户规格', 'dispatchOrder': '委托单'})
self.assertEqual(task['filters']['columnFilters'][0]['values'], ['0012', 'A|B'])
self.assertEqual(task['filters']['columnFilters'][0]['stages'], ['black'])
self.assertEqual(task['filters']['columnFilters'][1]['stages'], ['bright'])
self.assertEqual(task['filters']['columnFilters'][2]['stages'], ['black', 'bright'])
def test_column_filter_rules_are_complete_replace_clear_and_inherit(self):
previous = protocol_task(columnFilters=[RULES[0]])
context = bind_task({'_protocol': {'version': 1}, '_businessCatalog': CATALOG}, previous)
inherited = normalize_task(task_value(kind='metrics', dimensions=[], stages=['black'], fields=['rate'],
period={'year': 2026, 'month': 3}, columnFilters=None), '继续查询', context)
self.assertEqual(inherited['filters']['columnFilters'], []) # explicit null clears
omitted = task_value(kind='metrics', dimensions=[], stages=['black'], fields=['rate'],
period={'year': 2026, 'month': 3})
self.assertEqual(normalize_task(omitted, '继续查询', context)['filters']['columnFilters'], [RULES[0]])
omitted['columnFilters'] = [RULES[1]]
self.assertEqual(normalize_task(omitted, '改查亮片规格', context)['filters']['columnFilters'], [RULES[1]])
cleared = normalize_task({**omitted, 'columnFilters': []}, '清除原表列条件', context)
self.assertEqual(cleared['filters']['columnFilters'], [])
cleared_context = bind_task(context, cleared)
self.assertEqual(normalize_task(omitted | {'columnFilters': None}, '继续', cleared_context)['filters']['columnFilters'], [])
new_task = normalize_task({**omitted, 'newTask': True, 'columnFilters': None}, '另开任务', context)
self.assertEqual(new_task['filters']['columnFilters'], [])
def test_unauthorized_unknown_and_missing_stage_columns_fail_closed(self):
for bad in ([{**RULES[0], 'field': 'notInDirectory'}],
[{**RULES[0], 'field': 'blackOnlyCode', 'stages': ['bright']}],
[{**RULES[0], 'operator': 'contains'}]):
with self.subTest(bad=bad), self.assertRaises(TaskUnavailable):
normalize_task(task_value(kind='metrics', dimensions=[], stages=['black'], fields=['rate'],
period={'year': 2026}, columnFilters=bad), '筛选原表字段',
{'_protocol': {'version': 1}, '_businessCatalog': CATALOG})
with self.assertRaisesRegex(TaskUnavailable, '目录不可用'):
normalize_task(task_value(kind='metrics', dimensions=[], stages=[], fields=['rate'],
columnFilters=[RULES[0]]), '按原表列过滤', {'_protocol': {'version': 1}, '_businessCatalog': {}})
def test_semantic_review_must_confirm_source_filters_and_member_projection(self):
source_plan = task_value(kind='metrics', dimensions=[], stages=['black'], fields=['rate'],
period={'year': 2026, 'month': 3}, columnFilters=[RULES[0]])
bad_review = {'aligned': True, 'requiresEvidence': True, 'requiresSourceVerification': False,
'requiresAllSourceRows': False, 'requiresTrend': False, 'requiresComparison': False,
'columnFiltersAligned': False}
with patch('nao_agent_task._model_json', side_effect=[source_plan, bad_review] * 3) as model:
with self.assertRaisesRegex(TaskUnavailable, '字段、阶段或成员清单'):
plan_task(base_url='https://offline.invalid/v1', api_key='never-used', model='m',
question='只看黑片批号 0012 的合格率',
context={'_protocol': {'version': 1}, '_businessCatalog': CATALOG},
cancel_event=threading.Event(), source_value_resolver=self._value_resolver)
self.assertEqual(model.call_count, 6)
self.assertTrue(model.call_args_list[1].kwargs['payload']['columnFilterReviewRequired'])
self.assertFalse(model.call_args_list[1].kwargs['payload']['memberListReviewRequired'])
member_plan = task_value(kind='members', dimensions=[], stages=['black'], fields=[],
period={'year': 2026, 'month': 3}, memberFields=['batchNumber'], columnFilters=[])
good_review = {'aligned': True, 'requiresEvidence': True, 'requiresSourceVerification': False,
'requiresAllSourceRows': False, 'requiresTrend': False, 'requiresComparison': False,
'memberListAligned': True}
with patch('nao_agent_task._model_json', side_effect=[member_plan, good_review]) as model:
planned = plan_task(base_url='https://offline.invalid/v1', api_key='never-used', model='m',
question='列出黑片批号清单',
context={'_protocol': {'version': 1}, '_businessCatalog': CATALOG},
cancel_event=threading.Event())
self.assertEqual(planned['kind'], 'members')
self.assertEqual(model.call_count, 2)
self.assertTrue(model.call_args_list[1].kwargs['payload']['memberListReviewRequired'])
@staticmethod
def _value_resolver(*, release_id, period, filters, field, stages, search, limit, offset):
return {'candidateOnly': True, 'releaseId': release_id, 'period': period, 'filters': filters,
'field': field, 'selectedStages': stages, 'offset': offset, 'limit': limit,
'totalCount': 1, 'hasMore': False, 'values': [search], 'rows': []}
def test_unconfirmed_source_value_is_clarified_without_partial_rule(self):
source_plan = task_value(kind='metrics', dimensions=[], stages=['black'], fields=['rate'],
period={'year': 2026, 'month': 3}, columnFilters=[
{'field': 'dispatchOrder', 'stages': ['black'], 'operator': 'in', 'values': ['宝鑫加工']}])
review = {'aligned': True, 'requiresEvidence': True, 'requiresSourceVerification': False,
'requiresAllSourceRows': False, 'requiresTrend': False, 'requiresComparison': False,
'columnFiltersAligned': True}
def resolver(**contract):
return {'candidateOnly': True, 'releaseId': contract['release_id'],
'period': contract['period'], 'filters': contract['filters'],
'field': contract['field'], 'selectedStages': contract['stages'],
'offset': contract['offset'], 'limit': contract['limit'],
'totalCount': 1, 'hasMore': False, 'values': ['宝鑫加工厂'], 'rows': []}
with patch('nao_agent_task._model_json', side_effect=[source_plan, review]) as model:
planned = plan_task(base_url='https://offline.invalid/v1', api_key='never-used', model='m',
question='按委托单宝鑫加工查询黑片合格率',
context={'_protocol': {'version': 1}, '_businessCatalog': CATALOG,
'releaseId': RELEASE}, cancel_event=threading.Event(), source_value_resolver=resolver)
self.assertTrue(planned['needsClarification'])
self.assertEqual(planned['filters']['columnFilters'], [])
self.assertIn('不会自动替换', planned['clarification'])
resolution = planned['sourceValueResolution']
self.assertEqual(resolution['status'], 'unconfirmed')
self.assertEqual(resolution['candidates'], ['宝鑫加工厂'])
def test_candidate_lookup_scopes_other_rules_to_the_requested_stage_only(self):
source_plan = task_value(kind='metrics', dimensions=[], stages=['black', 'bright'], fields=['rate'],
period={'year': 2026, 'month': 3}, columnFilters=RULES)
review = {'aligned': True, 'requiresEvidence': True, 'requiresSourceVerification': False,
'requiresAllSourceRows': False, 'requiresTrend': False, 'requiresComparison': False,
'columnFiltersAligned': True}
seen = []
def resolver(**contract):
seen.append(contract)
return {'candidateOnly': True, 'releaseId': contract['release_id'],
'period': contract['period'], 'filters': contract['filters'],
'field': contract['field'], 'selectedStages': contract['stages'],
'offset': contract['offset'], 'limit': contract['limit'],
'totalCount': 1, 'hasMore': False, 'values': [contract['search']], 'rows': []}
with patch('nao_agent_task._model_json', side_effect=[source_plan, review]):
planned = plan_task(base_url='https://offline.invalid/v1', api_key='never-used', model='m',
question='按黑片批号0012筛选,同时保留亮片客户规格条件',
context={'_protocol': {'version': 1}, '_businessCatalog': CATALOG,
'releaseId': RELEASE}, cancel_event=threading.Event(), source_value_resolver=resolver)
self.assertEqual(planned['filters']['columnFilters'], RULES)
self.assertEqual(len(seen), 3)
batch_lookup = next(call for call in seen if call['field'] == 'batchNumber')
self.assertEqual(batch_lookup['stages'], ['black'])
self.assertEqual(batch_lookup['filters']['columnFilters'], [
{'field': 'dispatchOrder', 'stages': ['black'], 'operator': 'not_empty'}])
customer_lookup = next(call for call in seen if call['field'] == 'customerSpec')
self.assertEqual(customer_lookup['stages'], ['bright'])
self.assertEqual(customer_lookup['filters']['columnFilters'], [
{'field': 'dispatchOrder', 'stages': ['bright'], 'operator': 'not_empty'}])
def test_missing_literal_offers_same_scope_alternatives_without_substitution(self):
from nao_agent_task import _resolve_source_column_values
task = protocol_task(columnFilters=[RULES[0]])
calls = []
def resolver(**contract):
calls.append(contract)
response = self._value_resolver(**contract)
response.update(values=[] if contract['search'] else ['亮片实际单位'],
totalCount=0 if contract['search'] else 1)
return response
result = _resolve_source_column_values(task, release_id=RELEASE, resolver=resolver)
self.assertEqual([c['search'] for c in calls], ['0012', ''])
self.assertEqual({k:v for k,v in calls[0].items() if k!='search'},
{k:v for k,v in calls[1].items() if k!='search'})
self.assertEqual(result['status'], 'unconfirmed')
self.assertEqual(result['candidates'], ['亮片实际单位'])
self.assertTrue(task['needsClarification'])
self.assertEqual(task['filters']['columnFilters'], [])
self.assertIn('亮片实际单位', task['clarification'])
def test_alternative_candidate_receipt_cannot_broaden_the_scope(self):
from nao_agent_task import _resolve_source_column_values
task = protocol_task(columnFilters=[RULES[0]])
def resolver(**contract):
response = self._value_resolver(**contract)
response.update(values=[] if contract['search'] else ['不能显示的其他阶段值'],
totalCount=0 if contract['search'] else 1)
if not contract['search']:response['selectedStages']=['bright']
return response
result = _resolve_source_column_values(task, release_id=RELEASE, resolver=resolver)
self.assertEqual(result['status'], 'unconfirmed')
self.assertEqual(result['candidates'], [])
self.assertNotIn('不能显示', task['clarification'])
self.assertEqual(task['filters']['columnFilters'], [])
def test_member_plan_repair_preserves_new_task_reset_and_customer_scope(self):
previous = protocol_task()
catalog = {**CATALOG, 'extraFields': [{'key': 'customerCode'}]}
context = bind_task({'_protocol': {'version': 1}, '_businessCatalog': catalog,
'releaseId': RELEASE}, previous)
good = task_value(kind='members', dimensions=[], stages=['black', 'bright'], fields=[],
memberFields=['product'], newTask=True, columnFilters=[],
period={'year':2026,'month':9}, filterUpdates={'extraFilters':{'customerCode':['800001']}})
bad = {**good, 'filterUpdates': {'customerCode':['800001']}}
review = {'aligned':True, 'requiresEvidence':True, 'requiresSourceVerification':False,
'requiresAllSourceRows':False, 'requiresTrend':False, 'requiresComparison':False,
'columnFiltersAligned':True, 'memberListAligned':True, 'customerCodes':['800001']}
with patch('nao_agent_task._model_json', side_effect=[bad,good,review]) as model:
planned = plan_task(base_url='https://offline.invalid/v1', api_key='never-used', model='m',
question='新任务:800001客户2026年9月有哪些规格,黑片亮片一起看',
context=context, previous=previous, cancel_event=threading.Event())
repair = model.call_args_list[1].kwargs['payload']
self.assertTrue(repair['invalidPlan']['newTask'])
self.assertEqual(planned['filters']['extraFilters'], {'customerCode':['800001']})
self.assertEqual(planned['filters']['columnFilters'], [])
self.assertEqual(planned['memberFields'], ['product'])
self.assertEqual(planned['stages'], ['black','bright'])
self.assertTrue(planned['newTask'])
def test_quality_tools_sends_column_filters_and_requires_exact_receipt(self):
with tempfile.TemporaryDirectory() as folder:
api = EchoColumnApi()
tools = QualityTools(api_factory=lambda: api, evidence_dir=folder)
result = tools.quality_data({'mode': 'query', 'releaseId': RELEASE,
'period': {'year': 2026, 'month': 3}, 'filters': {}, 'view': 'overall',
'columnFilters': RULES})
metrics_path = next(path for _, path, _ in api.calls if urlsplit(path).path == '/api/metrics')
sent = json.loads(parse_qs(urlsplit(metrics_path).query)['columnFilters'][0])
self.assertEqual(sent, RULES)
self.assertEqual(result['filters']['columnFilters'], RULES)
self.assertEqual(result['trend'][0]['period'], '2026-03')
with tempfile.TemporaryDirectory() as folder:
tools = QualityTools(api_factory=lambda: EchoColumnApi(echo='mismatch'), evidence_dir=folder)
with self.assertRaisesRegex(QualityToolError, '未原样确认 filters.columnFilters'):
tools.quality_data({'mode': 'query', 'releaseId': RELEASE,
'period': {'year': 2026, 'month': 3}, 'filters': {}, 'view': 'overall',
'columnFilters': RULES})
with tempfile.TemporaryDirectory() as folder:
tools = QualityTools(api_factory=lambda: EchoColumnApi(echo='missing'), evidence_dir=folder)
with self.assertRaisesRegex(QualityToolError, '未原样确认 filters.columnFilters'):
tools.quality_data({'mode': 'query', 'releaseId': RELEASE,
'period': {'year': 2026, 'month': 3}, 'filters': {}, 'view': 'overall',
'columnFilters': RULES})
def test_query_contract_extracts_authoritative_filters_and_rejects_changes(self):
task = protocol_task()
contract = {'task': task, 'releaseId': RELEASE}
args = {'mode': 'query', 'period': task['period'], 'filters': {}, 'view': 'overall'}
bound = bind_query(args, contract)
self.assertEqual(bound['columnFilters'], RULES)
self.assertNotIn('columnFilters', bound['filters'])
with self.assertRaisesRegex(ValueError, '偏离本轮任务约定'):
bind_query({**args, 'columnFilters': [RULES[0]]}, contract)
with self.assertRaisesRegex(ValueError, '只能用于已确认的正式query'):
bind_query({'mode': 'changes'}, contract)
def member_task(self, stages=('black', 'bright')):
value = task_value(kind='members', dimensions=[], fields=[], stages=list(stages),
period={'year': 2026, 'month': 3}, comparisonRequired=False, trendRequired=False,
memberFields=['batchNumber', 'dispatchOrder'], columnFilters=[])
task = normalize_task(value, '列出委托单和批号',
{'_protocol': {'version': 1}, '_businessCatalog': CATALOG})
task['filters'].pop('columnFilters', None) # confirmed backend state omits cleared filters
return task
def _member_page(self, payload, offset, total, rows, *, proof=True):
response = {'rows': rows, 'totalCount': total, 'offset': offset, 'limit': 200,
'hasMore': offset + len(rows) < total,
'complete': offset == 0 and offset + len(rows) >= total,
'pageComplete': True,
'releaseId': payload['releaseId'], 'filters': payload['filters'],
'period': payload['period'], 'memberFields': payload['memberFields'],
'selectedStages': payload['stages']}
if proof:
response['protocolEvidence'] = {'queryId': f'q-{offset}', **AUTHORITY, 'responseHash': 'a' * 64}
return response
def test_members_paginates_checks_each_proof_and_renders_without_model(self):
class MemberApi:
def __init__(self): self.calls = []
def call(self, path, payload=None, method=None):
self.calls.append((path, payload, method))
rows = ([{'values': {'batchNumber': '001|A' if i == 0 else f'B-{i}',
'dispatchOrder': 'https://bad.test/<img>' if i == 0 else f'委托-{i}'},
'stages': ['black', 'bright']} for i in range(200)]
if payload['offset'] == 0 else
[{'values': {'batchNumber': None, 'dispatchOrder': '委托-2'}, 'stages': ['bright']}])
return SourceColumnProtocolTests()._member_page(payload, payload['offset'], 201, rows)
api = MemberApi()
task = self.member_task()
with tempfile.TemporaryDirectory() as folder:
root = Path(folder); (root / 'evidence').mkdir(); (root / 'private').mkdir()
with patch('nao_evidence_finalizer.synthesize') as synth:
result = execute(request={'releaseId': RELEASE, 'turnId': AUTHORITY['turnId'], 'question': task['question']},
task=task, authority=AUTHORITY, actor_root=root, delegated=api,
connection=('offline', 'secret-unused', 'model-id'), cancel_event=threading.Event(), emit=lambda _: None)
self.assertEqual(result['status'], 'COMPLETED')
self.assertEqual(len(result['protocolEvidence']), 2)
self.assertEqual(result['queryEvidenceRefs'], [])
self.assertEqual(result['visualState'], 'not_requested')
self.assertIn('共 201 个去重项,已查全', result['answer'])
self.assertNotIn('<img>', result['answer'])
self.assertIn('翻页查看全部', result['answer'])
self.assertTrue(result['evidenceCompletion']['serverCoverageSufficient'])
self.assertEqual(len(api.calls), 2)
self.assertEqual(api.calls[0][1]['offset'], 0)
self.assertEqual(api.calls[1][1]['offset'], 200)
self.assertNotIn('columnFilters', api.calls[0][1]['filters'])
self.assertFalse(synth.called)
proof_store = json.loads((root / 'private' / 'protocol-members-evidence.json').read_text())
self.assertEqual(len(proof_store['pages']), 2)
self.assertEqual(proof_store['displayedCount'], 201)
self.assertTrue(proof_store['displayComplete'])
self.assertEqual(proof_store['pages'][0]['response']['rows'][0]['values']['dispatchOrder'], 'https://bad.test/<img>')
self.assertEqual(len(json.loads((root / 'private' / 'protocol-completion.json').read_text())['protocolEvidence']), 2)
def test_members_empty_result_and_proof_failure_are_distinct(self):
task = self.member_task(('black',))
class EmptyApi:
def call(inner, path, payload=None, method=None):
return SourceColumnProtocolTests()._member_page(payload, 0, 0, [])
with tempfile.TemporaryDirectory() as folder:
root = Path(folder); (root / 'evidence').mkdir(); (root / 'private').mkdir()
empty = execute(request={'releaseId': RELEASE, 'question': task['question']}, task=task,
authority=AUTHORITY, actor_root=root, delegated=EmptyApi(),
connection=('offline', 'key', 'm'), cancel_event=threading.Event(), emit=lambda _: None)
self.assertEqual(empty['status'], 'COMPLETED')
self.assertIn('共 0 个去重项,已查全', empty['answer'])
class NoProof(EmptyApi):
def call(inner, path, payload=None, method=None):
return SourceColumnProtocolTests()._member_page(payload, 0, 0, [], proof=False)
with tempfile.TemporaryDirectory() as folder:
root = Path(folder); (root / 'evidence').mkdir(); (root / 'private').mkdir()
with self.assertRaisesRegex(ValueError, '缺少完整协议证明'):
execute(request={'releaseId': RELEASE, 'question': task['question']}, task=task,
authority=AUTHORITY, actor_root=root, delegated=NoProof(),
connection=('offline', 'key', 'm'), cancel_event=threading.Event(), emit=lambda _: None)
def test_members_stops_after_twenty_pages_and_marks_truncation(self):
task = self.member_task(('black',))
class LargeApi:
def __init__(self): self.calls = 0
def call(inner, path, payload=None, method=None):
inner.calls += 1
rows = [{'values': {'batchNumber': str(payload['offset'] + i), 'dispatchOrder': 'D'},
'stages': ['black']} for i in range(200)]
return SourceColumnProtocolTests()._member_page(payload, payload['offset'], 5000, rows)
api = LargeApi()
with tempfile.TemporaryDirectory() as folder:
root = Path(folder); (root / 'evidence').mkdir(); (root / 'private').mkdir()
result = execute(request={'releaseId': RELEASE, 'question': task['question']}, task=task,
authority=AUTHORITY, actor_root=root, delegated=api,
connection=('offline', 'key', 'm'), cancel_event=threading.Event(), emit=lambda _: None)
self.assertEqual(api.calls, 20)
self.assertEqual(result['status'], 'PARTIAL')
self.assertEqual(len(result['protocolEvidence']), 20)
self.assertFalse(result['evidenceCompletion']['serverCoverageSufficient'])
self.assertIn('另有 1000 项未读取', result['answer'])
if __name__ == '__main__':
unittest.main()