737 lines
49 KiB
Python
737 lines
49 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_single_product_combined_metric_uses_one_filtered_combined_ranking_node(self):
|
|
product = 'PX-73X4.2XR26.4-VariantB'
|
|
question = f'2026年9月{product}的综合合格率和黑片亮片合计报废总重是多少?只用文字回答。'
|
|
plan = {
|
|
'goal': '查询指定完整规格的综合合格率和黑片、亮片合计报废总重',
|
|
'kind': 'metrics', 'filterUpdates': {'product': product},
|
|
'period': {'year': 2026, 'month': 9}, 'comparisonPeriod': None,
|
|
'comparisonRequired': False, 'trendRequired': False,
|
|
'dimensions': ['product'], 'dimensionStages': {'product': []},
|
|
'stages': [], 'fields': ['rate', 'scrapWeight'],
|
|
'freshQuery': True, 'verifySource': False, 'fullDetails': False,
|
|
'needsClarification': False, 'clarification': '',
|
|
'visualPreference': 'none', 'visualType': None,
|
|
'queryPlan': [{
|
|
'nodeId': 'single_product', 'purpose': 'ranking', 'dimension': 'product',
|
|
'limit': 1, 'fields': ['rate', 'scrapWeight'], 'stages': [],
|
|
'selector': {'kind': 'base'}, 'visualType': None,
|
|
'visualPreference': 'none', 'comparisonRequired': False,
|
|
}],
|
|
}
|
|
review = {'aligned': True, 'requiresEvidence': True,
|
|
'requiresSourceVerification': False, 'requiresAllSourceRows': False,
|
|
'requiresTrend': False, 'requiresComparison': False}
|
|
for protocol, replies in (
|
|
({'version': 1}, [plan, review]),
|
|
({'version': 1, 'autonomousEnabled': True}, [plan])):
|
|
with self.subTest(autonomous=protocol.get('autonomousEnabled', False)):
|
|
context = {'_protocol': protocol}
|
|
with patch('nao_agent_task._model_json', side_effect=replies) as model:
|
|
task = plan_task(base_url='https://offline.invalid/v1', api_key='unused', model='m',
|
|
question=question, context=context, cancel_event=threading.Event())
|
|
self.assertEqual(task['kind'], 'metrics')
|
|
self.assertEqual(task['filters']['product'], product)
|
|
self.assertEqual(task['dimensions'], ['product'])
|
|
self.assertEqual(task['fields'], ['rate', 'scrapWeight'])
|
|
self.assertEqual(task['stages'], [])
|
|
self.assertEqual(task['dimensionStages']['product'], [])
|
|
self.assertEqual(len(task['queryPlan']), 1)
|
|
node = task['queryPlan'][0]
|
|
self.assertEqual((node['purpose'], node['dimension'], node['limit']),
|
|
('ranking', 'product', 1))
|
|
self.assertEqual(node['fields'], ['rate', 'scrapWeight'])
|
|
self.assertEqual(node['stages'], [])
|
|
self.assertEqual(node['visualPreference'], 'none')
|
|
self.assertIn('limit=1', model.call_args_list[0].kwargs['system'])
|
|
self.assertIn('合计算子', model.call_args_list[0].kwargs['system'])
|
|
|
|
from nao_protocol_execution import _scoped_arguments
|
|
args = _scoped_arguments({'releaseId': 'release-test'}, {'task': task}, node)
|
|
self.assertEqual(len(args), 1)
|
|
self.assertIsNone(args[0]['stage'])
|
|
self.assertEqual(args[0]['metric'], 'scrapWeight')
|
|
|
|
def test_unqualified_bad_top_stays_combined_product_ranking_under_exact_product_filter(self):
|
|
product = 'DYN-SPEC-0.795+0.937X1.498X7'
|
|
question = f'2026年9月只看规格{product}的不良TOP5。'
|
|
plan = {
|
|
'goal': '按用户给出的完整产品规格范围列出不良TOP5',
|
|
'kind': 'analysis', 'filterUpdates': {'product': product},
|
|
'period': {'year': 2026, 'month': 9}, 'comparisonPeriod': None,
|
|
'comparisonRequired': False, 'trendRequired': False,
|
|
'dimensions': ['product'], 'dimensionStages': {'product': []},
|
|
'stages': [], 'fields': ['rate', 'scrapWeight'],
|
|
'freshQuery': True, 'verifySource': False, 'fullDetails': False,
|
|
'needsClarification': False, 'clarification': '',
|
|
'visualPreference': 'auto', 'visualType': 'bar',
|
|
'queryPlan': [{
|
|
'nodeId': 'product_top', 'purpose': 'ranking', 'dimension': 'product',
|
|
'limit': 5, 'fields': ['rate', 'scrapWeight'], 'stages': [],
|
|
'selector': {'kind': 'base'}, 'visualType': 'bar',
|
|
'visualPreference': 'auto', 'comparisonRequired': False,
|
|
}],
|
|
}
|
|
review = {'aligned': True, 'requiresEvidence': True,
|
|
'requiresSourceVerification': False, 'requiresAllSourceRows': False,
|
|
'requiresTrend': False, 'requiresComparison': False}
|
|
for protocol, replies in (
|
|
({'version': 1}, [plan, review]),
|
|
({'version': 1, 'autonomousEnabled': True}, [plan])):
|
|
with self.subTest(autonomous=protocol.get('autonomousEnabled', False)):
|
|
with patch('nao_agent_task._model_json', side_effect=replies) as model:
|
|
task = plan_task(base_url='https://offline.invalid/v1', api_key='unused', model='m',
|
|
question=question, context={'_protocol': protocol}, cancel_event=threading.Event())
|
|
self.assertEqual(task['kind'], 'analysis')
|
|
self.assertEqual(task['filters']['product'], product)
|
|
self.assertEqual(task['dimensions'], ['product'])
|
|
self.assertEqual(task['fields'], ['rate', 'scrapWeight'])
|
|
self.assertEqual(task['stages'], [])
|
|
self.assertEqual(task['dimensionStages']['product'], [])
|
|
self.assertNotIn('缺陷', task['goal'])
|
|
self.assertEqual(len(task['queryPlan']), 1)
|
|
node = task['queryPlan'][0]
|
|
self.assertEqual((node['purpose'], node['dimension'], node['limit']),
|
|
('ranking', 'product', 5))
|
|
self.assertEqual(node['stages'], [])
|
|
self.assertNotIn('defects', [item['purpose'] for item in task['queryPlan']])
|
|
self.assertIn('空榜', model.call_args_list[0].kwargs['system'])
|
|
|
|
from nao_protocol_execution import _scoped_arguments
|
|
args = _scoped_arguments({'releaseId': 'release-test'}, {'task': task}, node)
|
|
self.assertEqual(len(args), 1)
|
|
self.assertIsNone(args[0]['stage'])
|
|
self.assertEqual(args[0]['metric'], 'scrapWeight')
|
|
|
|
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_member_fields_must_match_the_requested_entity_not_lookalike_or_filter_columns(self):
|
|
canonical_product = {**SOURCE_FIELDS[0], 'type': 'dimension'}
|
|
product_spec = source_field('src_dynamic_product_spec_0', '产品规格', '黑片规格', '亮片规格')
|
|
drawing = source_field('src_dynamic_drawing_1', '产品图号', '图号-黑片', '图号-亮片')
|
|
customer_code = source_field('src_dynamic_customer_2', '客户代码', '客户编码-黑片', '客户编码-亮片')
|
|
customer_spec = source_field('src_dynamic_customer_spec_3', '客户规格', '客户规格-黑片', '客户规格-亮片')
|
|
catalog = {'sourceFields': [canonical_product, product_spec, drawing, customer_code, customer_spec],
|
|
'extraFields': [{'key': 'customerCode', 'label': '客户代码'}],
|
|
'departments': [], 'groups': []}
|
|
context = {'_protocol': {'version': 1}, '_businessCatalog': catalog}
|
|
question = '800001客户都有哪些规格?'
|
|
wrong = task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
|
period={'year': 2026, 'month': 9}, comparisonRequired=False, trendRequired=False,
|
|
memberFields=[drawing['key'], customer_code['key']], columnFilters=[],
|
|
filterUpdates={'extraFilters': {'customerCode': ['800001']}})
|
|
with self.assertRaises(TaskUnavailable) as raised:
|
|
normalize_task(wrong, question, context)
|
|
self.assertEqual(raised.exception.field, 'memberFields')
|
|
self.assertIn('产品规格', str(raised.exception))
|
|
|
|
correct = normalize_task({**wrong, 'memberFields': [product_spec['key']]}, question, context)
|
|
self.assertEqual(correct['memberFields'], [product_spec['key']])
|
|
self.assertEqual(correct['sourceFieldLabels'], {product_spec['key']: '产品规格'})
|
|
self.assertEqual(correct['filters']['extraFilters'], {'customerCode': ['800001']})
|
|
|
|
drawing_task = {**wrong, 'memberFields': [drawing['key']]}
|
|
drawing_result = normalize_task(drawing_task, '800001客户的产品图号有哪些?', context)
|
|
self.assertEqual(drawing_result['memberFields'], [drawing['key']])
|
|
|
|
without_product_spec = {'sourceFields': [canonical_product, drawing, customer_code],
|
|
'extraFields': [{'key': 'customerCode', 'label': '客户代码'}],
|
|
'departments': [], 'groups': []}
|
|
missing = normalize_task(wrong, question,
|
|
{'_protocol': {'version': 1}, '_businessCatalog': without_product_spec})
|
|
self.assertTrue(missing['needsClarification'])
|
|
self.assertEqual(missing['memberFields'], [])
|
|
self.assertIn('没有可用于', missing['clarification'])
|
|
|
|
customer_spec_task = task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
|
period={'year': 2026, 'month': 9}, comparisonRequired=False, trendRequired=False,
|
|
memberFields=[customer_spec['key']], columnFilters=[])
|
|
customer_spec_result = normalize_task(customer_spec_task, '800001客户有哪些客户规格?', context)
|
|
self.assertEqual(customer_spec_result['memberFields'], [customer_spec['key']])
|
|
with self.assertRaises(TaskUnavailable) as rejected:
|
|
normalize_task({**customer_spec_task, 'memberFields': [product_spec['key']]}, '800001客户有哪些客户规格?', context)
|
|
self.assertEqual(rejected.exception.field, 'memberFields')
|
|
|
|
def test_ambiguous_member_spec_columns_force_clarification_without_a_query(self):
|
|
primary = source_field('src_dynamic_product_spec_1', '产品规格', '规格-黑片', '规格-亮片')
|
|
secondary = source_field('src_dynamic_finished_spec_2', '成品规格', '成品规格-黑片', '成品规格-亮片')
|
|
material_spec = source_field('src_dynamic_material_spec_3', '原材料规格', '原料规格-黑片', '原料规格-亮片')
|
|
version = source_field('src_dynamic_spec_version_4', '规格版本', '规格版本-黑片', '规格版本-亮片')
|
|
catalog = {'sourceFields': [primary, secondary, material_spec, version], 'departments': [], 'groups': []}
|
|
planned = normalize_task(task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
|
period={'year': 2026, 'month': 9}, memberFields=[primary['key']], columnFilters=[]), '列出本期规格清单',
|
|
{'_protocol': {'version': 1}, '_businessCatalog': catalog})
|
|
self.assertTrue(planned['needsClarification'])
|
|
self.assertEqual(planned['memberFields'], [])
|
|
self.assertIn('多个', planned['clarification'])
|
|
|
|
explicit = normalize_task(task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
|
period={'year': 2026, 'month': 9}, memberFields=[secondary['key']], columnFilters=[]),
|
|
'列出本期成品规格清单', {'_protocol': {'version': 1}, '_businessCatalog': catalog})
|
|
self.assertFalse(explicit['needsClarification'])
|
|
self.assertEqual(explicit['memberFields'], [secondary['key']])
|
|
|
|
def test_member_semantics_keep_multiple_requested_entities_and_ignore_lookalike_labels(self):
|
|
product_spec = source_field('src_dynamic_product_spec_5', '产品规格', '产品规格-黑片', '产品规格-亮片')
|
|
customer_spec = source_field('src_dynamic_customer_spec_6', '客户规格', '客户规格-黑片', '客户规格-亮片')
|
|
material_spec = source_field('src_dynamic_material_spec_7', '原材料规格', '原料规格-黑片', '原料规格-亮片')
|
|
spec_version = source_field('src_dynamic_version_8', '规格版本', '规格版本-黑片', '规格版本-亮片')
|
|
catalog = {'sourceFields': [product_spec, customer_spec, material_spec, spec_version],
|
|
'departments': [], 'groups': []}
|
|
value = task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
|
period={'year': 2026, 'month': 9}, memberFields=[customer_spec['key'], product_spec['key']], columnFilters=[])
|
|
planned = normalize_task(value, '列出成品规格,并显示客户规格',
|
|
{'_protocol': {'version': 1}, '_businessCatalog': catalog})
|
|
self.assertFalse(planned['needsClarification'])
|
|
self.assertEqual(set(planned['memberFields']), {product_spec['key'], customer_spec['key']})
|
|
|
|
negated = normalize_task({**value, 'memberFields': [product_spec['key']]},
|
|
'列出成品规格,不要显示客户规格',
|
|
{'_protocol': {'version': 1}, '_businessCatalog': catalog})
|
|
self.assertFalse(negated['needsClarification'])
|
|
self.assertEqual(negated['memberFields'], [product_spec['key']])
|
|
|
|
raw_material = source_field('src_dynamic_raw_material_spec_9', '原材料规格', '原材料规格黑片', '原材料规格亮片')
|
|
explicit_label_catalog = {'sourceFields': [product_spec, raw_material, spec_version],
|
|
'departments': [], 'groups': []}
|
|
raw_material_result = normalize_task({**value, 'memberFields': [raw_material['key']]},
|
|
'列出原材料规格',
|
|
{'_protocol': {'version': 1}, '_businessCatalog': explicit_label_catalog})
|
|
self.assertFalse(raw_material_result['needsClarification'])
|
|
self.assertEqual(raw_material_result['memberFields'], [raw_material['key']])
|
|
|
|
only_product_spec_catalog = {'sourceFields': [product_spec, material_spec, spec_version],
|
|
'departments': [], 'groups': []}
|
|
single = normalize_task({**value, 'memberFields': [product_spec['key']]}, '列出本期规格清单',
|
|
{'_protocol': {'version': 1}, '_businessCatalog': only_product_spec_catalog})
|
|
self.assertEqual(single['memberFields'], [product_spec['key']])
|
|
|
|
def test_member_semantic_repair_uses_this_turn_catalog_and_does_not_add_another_reviewer(self):
|
|
canonical_product = {**SOURCE_FIELDS[0], 'type': 'dimension'}
|
|
product_spec = source_field('src_run_product_spec_7', '产品规格', '产品规格黑片', '产品规格亮片')
|
|
drawing = source_field('src_run_drawing_9', '产品图号', '图号-黑片', '图号-亮片')
|
|
customer_code = source_field('src_run_code_8', '客户代码', '客户编码-黑片', '客户编码-亮片')
|
|
catalog = {'sourceFields': [canonical_product, product_spec, drawing, customer_code],
|
|
'extraFields': [{'key': 'customerCode', 'label': '客户代码'}],
|
|
'departments': [], 'groups': []}
|
|
question = '800001客户都有哪些规格?'
|
|
context = {'_protocol': {'version': 1, 'autonomousEnabled': True}, '_businessCatalog': catalog}
|
|
base = task_value(kind='members', goal='列出客户800001的产品规格清单', dimensions=[], fields=[],
|
|
stages=['black', 'bright'], period={'year': 2026, 'month': 9}, comparisonRequired=False,
|
|
trendRequired=False, memberFields=[drawing['key'], customer_code['key']], columnFilters=[],
|
|
filterUpdates={'extraFilters': {'customerCode': ['800001']}}, visualPreference='none')
|
|
repaired = {**base, 'memberFields': [product_spec['key']]}
|
|
with patch('nao_agent_task._model_json', side_effect=[base, repaired]) as model:
|
|
planned = plan_task(base_url='https://offline.invalid/v1', api_key='never-used', model='m',
|
|
question=question, context=context, cancel_event=threading.Event())
|
|
self.assertEqual(planned['memberFields'], [product_spec['key']])
|
|
self.assertEqual(model.call_count, 2)
|
|
repair_payload = model.call_args_list[1].kwargs['payload']
|
|
self.assertEqual(repair_payload['validationDetails']['field'], 'memberFields')
|
|
self.assertIn('产品图号', str(repair_payload['businessCatalog']['sourceFields']))
|
|
self.assertIn('memberFields', model.call_args_list[0].kwargs['system'])
|
|
self.assertIn('图号', model.call_args_list[0].kwargs['system'])
|
|
self.assertIn('产品规格', model.call_args_list[0].kwargs['system'])
|
|
|
|
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)
|
|
product_spec = source_field('src_dynamic_new_task_spec', '产品规格', '产品规格黑片', '产品规格亮片')
|
|
catalog['sourceFields'] = [*SOURCE_FIELDS, product_spec]
|
|
context['_businessCatalog'] = catalog
|
|
good = task_value(kind='members', dimensions=[], stages=['black', 'bright'], fields=[],
|
|
memberFields=[product_spec['key']], 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_spec['key']])
|
|
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()
|