tradingSystem/scripts/test_price_limits_core.py

211 lines
11 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""限制价主源纯逻辑回归。虚构数据、无配置、无网络。"""
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)