tradingSystem/scripts/test_price_limits_core.py

211 lines
11 KiB
Python
Raw Normal View History

"""限制价主源纯逻辑回归。虚构数据、无配置、无网络。"""
import unit_test_guard
import copy
from datetime import date, datetime
from decimal import Decimal, localcontext
import json
from pathlib import Path
import sys
import unittest
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from app.core.price_limits import MAX_ROWS, REQUIRED_FIELDS, normalize_rows, provider_decode, supported
DAY = '2026-11-03'
CODE = '600000.SH'
OTHER = '000001.SZ'
def row(**changes):
return {'trade_date': '20261103', 'ts_code': CODE, 'pre_close': '10.00',
'up_limit': '11.00', 'down_limit': '9.00', **changes}
def body(rows=None, fields=None):
fields = list(fields or REQUIRED_FIELDS)
rows = [row()] if rows is None else rows
return {'code': 0, 'msg': 'must-not-be-echoed',
'data': {'fields': fields, 'items': [[value.get(field) for field in fields] for value in rows]}}
class PriceLimitCoreTests(unittest.TestCase):
def test_supported_codes_are_only_shenzhen_shanghai_a_shares(self):
for code in ('600000.SH', '688001.SH', '000001.SZ', '300001.SZ', ' 600000.sh '):
self.assertTrue(supported(code))
for code in ('920001.BJ', '430001.BJ', '920001.SH', '600000.SZ', '000001.SH',
'SH600000', '600000', '510300.SH', '888888.SH', None, True):
self.assertFalse(supported(code))
def test_dates_normalize_without_substituting_today(self):
for target in ('20261103', 20261103, DAY, date(2026, 11, 3), datetime(2026, 11, 3)):
for source in ('20261103', 20261103, DAY, date(2026, 11, 3)):
result = normalize_rows([row(trade_date=source)], target)
self.assertEqual(result['records'][CODE]['trade_date'], DAY)
def test_invalid_target_date_rejects_entire_batch(self):
for value in (None, True, 20261103.0, '2026-02-30', '202611', '2026-11-03T00:00:00'):
result = normalize_rows([row()], value)
self.assertEqual(result['errors'], ['INVALID_TARGET_DATE'])
self.assertEqual(result['records'], {})
def test_wrong_day_only_quarantines_affected_security(self):
result = normalize_rows([row(trade_date='20261102'), row(ts_code=OTHER)], DAY)
self.assertEqual(result['invalid'], {CODE: 'DATE_MISMATCH'})
self.assertEqual(set(result['records']), {OTHER})
def test_correct_date_cannot_hide_same_security_wrong_date(self):
for values in ([row(), row(trade_date='20261102')], [row(trade_date='20261102'), row()]):
result = normalize_rows(values, DAY)
self.assertEqual(result['records'], {})
self.assertEqual(result['invalid'][CODE], 'DATE_MISMATCH')
def test_malformed_row_date_is_not_accepted(self):
result = normalize_rows([row(trade_date='20261340')], DAY)
self.assertEqual(result['invalid'], {CODE: 'INVALID_DATE'})
def test_nan_bool_infinity_and_negative_prices_rejected(self):
for field in ('pre_close', 'up_limit', 'down_limit'):
for bad in (float('nan'), float('inf'), Decimal('NaN'), Decimal('sNaN'),
Decimal('Infinity'), True, False, -1, None, 'oops', '1e999999'):
with self.subTest(field=field, bad=repr(bad)):
result = normalize_rows([row(**{field: bad})], DAY)
self.assertEqual(result['records'], {})
self.assertEqual(result['invalid'], {CODE: 'INVALID_PRICE'})
def test_zero_limits_are_unsupported_without_fabrication(self):
for changes in ({'up_limit': 0}, {'down_limit': '0'}, {'up_limit': 0, 'down_limit': 0}):
result = normalize_rows([row(**changes)], DAY)
self.assertEqual(result['invalid'], {CODE: 'UNSUPPORTED'})
self.assertFalse(result['records'])
def test_preclose_must_be_positive_and_within_inclusive_limits(self):
for close, error in ((0, 'INVALID_PRE_CLOSE'), ('8.99', 'PRE_CLOSE_OUTSIDE_LIMITS'),
('11.01', 'PRE_CLOSE_OUTSIDE_LIMITS')):
self.assertEqual(normalize_rows([row(pre_close=close)], DAY)['invalid'][CODE], error)
for close in ('9.00', '11.00'):
self.assertIn(CODE, normalize_rows([row(pre_close=close)], DAY)['records'])
def test_equal_or_inverted_limits_are_rejected(self):
for changes in ({'down_limit': 11}, {'down_limit': 12}):
self.assertEqual(normalize_rows([row(**changes)], DAY)['invalid'][CODE], 'INVALID_RANGE')
def test_subcent_values_are_rejected_instead_of_rounded(self):
for field in ('pre_close', 'up_limit', 'down_limit'):
result = normalize_rows([row(**{field: '10.001'})], DAY)
self.assertEqual(result['invalid'][CODE], 'INVALID_PRECISION')
result = normalize_rows([row(pre_close=10.000000000000002)], DAY)
self.assertEqual(result['invalid'][CODE], 'INVALID_PRECISION')
def test_decimal_equivalents_have_same_content_version(self):
expected = normalize_rows([row()], DAY)['records'][CODE]
equivalents = row(pre_close=10, up_limit=Decimal('11.0000'), down_limit=9.0)
actual = normalize_rows([equivalents], DAY)['records'][CODE]
self.assertEqual(expected, actual)
self.assertEqual(expected['pre_close'], '10.00')
self.assertEqual(len(expected['version']), 64)
json.dumps(actual, allow_nan=False)
changed = normalize_rows([row(up_limit='11.01')], DAY)['records'][CODE]
self.assertNotEqual(expected['version'], changed['version'])
def test_decimal_context_does_not_change_price_validation(self):
with localcontext() as context:
context.prec = 2
self.assertIn(CODE, normalize_rows([row(pre_close='10.01')], DAY)['records'])
def test_identical_duplicates_deduplicate_but_conflicts_poison_security(self):
result = normalize_rows([row(), row(pre_close=10.0)], DAY)
self.assertEqual(len(result['records']), 1)
self.assertEqual(result['invalid'], {})
for values in ([row(), row(up_limit='12.00'), row()],
[row(up_limit='12.00'), row(), row(up_limit='12.00')]):
result = normalize_rows(values+[row(ts_code=OTHER)], DAY)
self.assertEqual(result['invalid'], {CODE: 'DUPLICATE_CONFLICT'})
self.assertEqual(set(result['records']), {OTHER})
def test_bad_price_row_cannot_be_hidden_by_good_duplicate(self):
for values in ([row(), row(pre_close=False)], [row(pre_close=False), row()]):
result = normalize_rows(values, DAY)
self.assertFalse(result['records'])
self.assertEqual(result['invalid'][CODE], 'INVALID_PRICE')
def test_requested_scope_rejects_unknown_return_code(self):
result = normalize_rows([row(), row(ts_code=OTHER)], DAY, [CODE])
self.assertEqual(result['invalid'], {OTHER: 'NOT_REQUESTED'})
self.assertEqual(set(result['records']), {CODE})
for codes in (None, []):
self.assertEqual(len(normalize_rows([row(), row(ts_code=OTHER)], DAY, codes)['records']), 2)
def test_beijing_is_rejected_at_entry_without_examining_its_prices(self):
result = normalize_rows([row(ts_code='920001.BJ', pre_close=False), row()], DAY)
self.assertEqual(result['invalid'], {'920001.BJ': 'OUT_OF_SCOPE'})
self.assertEqual(set(result['records']), {CODE})
def test_missing_local_field_is_isolated_and_input_is_unchanged(self):
missing = row()
missing.pop('pre_close')
values = [missing, row(ts_code=OTHER)]
snapshot = copy.deepcopy(values)
result = normalize_rows(values, DAY)
self.assertEqual(result['invalid'], {CODE: 'MISSING_FIELD'})
self.assertEqual(set(result['records']), {OTHER})
self.assertEqual(values, snapshot)
def test_invalid_collection_structure_is_top_level_error(self):
for rows in (None, {}, 'secret', [row(), None]):
result = normalize_rows(rows, DAY)
self.assertTrue(result['errors'])
self.assertFalse(result['records'])
for requested in ('600000.SH', ['920001.BJ'], [False]):
self.assertEqual(normalize_rows([row()], DAY, requested)['errors'], ['INVALID_REQUESTED_CODES'])
def test_provider_field_order_and_extra_fields_are_supported(self):
fields = ['unused']+list(reversed(REQUIRED_FIELDS))
result = provider_decode(body(fields=fields), DAY, [CODE])
self.assertEqual(result, normalize_rows([row()], DAY, [CODE]))
def test_provider_errors_never_echo_secret_message_or_arbitrary_code(self):
secret = 'secret-token-must-not-appear'
for value in ({'code': -2001, 'msg': secret}, {'code': False, 'data': secret},
{'code': '0', 'msg': secret}, {'code': 0, 'data': secret}, None):
result = provider_decode(value, DAY, [CODE])
self.assertTrue(result['errors'])
self.assertNotIn(secret, json.dumps(result))
result = normalize_rows([row(ts_code=secret)], DAY)
self.assertEqual(result['invalid'], {'row:1': 'INVALID_CODE'})
self.assertNotIn(secret, json.dumps(result))
def test_provider_missing_duplicate_or_invalid_fields_reject_batch(self):
for fields in ([], ['ts_code'], list(REQUIRED_FIELDS)+['ts_code'],
list(REQUIRED_FIELDS)+[False], list(REQUIRED_FIELDS)+[[]]):
value = body()
value['data']['fields'] = fields
result = provider_decode(value, DAY)
self.assertTrue(result['errors'])
self.assertFalse(result['records'])
def test_provider_item_structure_rejects_entire_batch(self):
for item in (None, {}, 'not-a-row', [CODE], list(range(len(REQUIRED_FIELDS)+1))):
value = body()
value['data']['items'].append(item)
result = provider_decode(value, DAY)
self.assertEqual(result['errors'], ['INVALID_PROVIDER_ITEM_STRUCTURE'])
self.assertFalse(result['records'])
def test_provider_maximum_rows_and_empty_response(self):
value = body()
value['data']['items'] *= MAX_ROWS
self.assertIn(CODE, provider_decode(value, DAY)['records'])
value['data']['items'].append(value['data']['items'][0])
self.assertEqual(provider_decode(value, DAY)['errors'], ['TOO_MANY_ROWS'])
self.assertEqual(normalize_rows([row()]*(MAX_ROWS+1), DAY)['errors'], ['TOO_MANY_ROWS'])
self.assertEqual(provider_decode(body(rows=[]), DAY), {'records': {}, 'invalid': {}, 'errors': []})
def test_provider_passes_through_per_security_quarantine(self):
result = provider_decode(body([row(trade_date='20261102'), row(ts_code=OTHER)]), DAY, [CODE, OTHER])
self.assertEqual(result['invalid'], {CODE: 'DATE_MISMATCH'})
self.assertEqual(set(result['records']), {OTHER})
if __name__ == '__main__':
unittest.main(verbosity=2)