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