tradingSystem/scripts/test_price_limit_provider.py

235 lines
11 KiB
Python
Raw Permalink Normal View History

"""限制价HTTP客户端的内存桩回归;不连接供应商、数据库或代理。"""
import unit_test_guard
import contextlib
import io
import json
import os
import sys
import unittest
from datetime import date
from unittest.mock import patch
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from app.services import price_limit_provider as provider
CODE = '688701.SH'
DAY = '2026-11-03'
TOKEN = 'unit-only-secret-canary-do-not-log'
def payload(items=None, **extra):
return {'code': 0, 'data': {'fields': provider.FIELDS.split(','),
'items': [[CODE, '20261103', 10, 12, 8]] if items is None else items}, **extra}
class FakeResponse:
def __init__(self, body=None, *, status=200, headers=None, chunks=None, failure=None):
self.status_code = status
self.headers = headers or {}
self.chunks = chunks if chunks is not None else [json.dumps(payload() if body is None else body).encode()]
self.failure = failure
self.closed = False
self.reads = 0
def iter_content(self, chunk_size):
self.chunk_size = chunk_size
for chunk in self.chunks:
self.reads += 1
yield chunk
if self.failure:
raise self.failure
def close(self):
self.closed = True
class FakeSession:
def __init__(self, response, failure=None):
self.response, self.failure = response, failure
self.trust_env = True
self.closed = False
self.calls = []
def post(self, url, **kwargs):
self.calls.append((url, kwargs, self.trust_env))
if self.failure:
raise self.failure
return self.response
def close(self):
self.closed = True
class ProviderTests(unittest.TestCase):
def request(self, response=None, *, code=CODE, day=DAY, token=TOKEN, timeout_sec=5,
failure=None, clock=None):
response = response or FakeResponse()
session = FakeSession(response, failure)
with contextlib.ExitStack() as stack:
factory = stack.enter_context(patch.object(provider.requests, 'Session', return_value=session))
if clock is not None:
stack.enter_context(patch.object(provider.time, 'monotonic', side_effect=clock))
result = provider.fetch_limit(code, day, token, timeout_sec)
return result, response, session, factory
def test_single_security_contract_and_normalized_date(self):
result, response, session, _ = self.request(code=' 688701.sh ', day=date(2026, 11, 3))
self.assertEqual(result['errors'], [])
self.assertEqual(list(result['records']), [CODE])
self.assertEqual(result['records'][CODE]['up_limit'], '12.00')
self.assertEqual(len(session.calls), 1)
url, kwargs, trust = session.calls[0]
self.assertEqual(url, 'https://api.tushare.pro')
self.assertEqual(kwargs['json']['api_name'], 'stk_limit')
self.assertEqual(kwargs['json']['params'], {'ts_code': CODE, 'trade_date': '20261103'})
self.assertEqual(kwargs['json']['fields'], provider.FIELDS)
self.assertTrue(kwargs['stream'])
self.assertFalse(kwargs['allow_redirects'])
self.assertFalse(trust)
self.assertEqual(kwargs['timeout'].total, 5.)
self.assertEqual(kwargs['timeout'].connect_timeout, 2.)
self.assertTrue(response.closed and session.closed)
def test_empty_success_remains_empty_without_error(self):
result, response, session, _ = self.request(FakeResponse(payload([])))
self.assertEqual(result, {'records': {}, 'invalid': {}, 'errors': []})
self.assertTrue(response.closed and session.closed)
def test_code_rejections_never_create_session(self):
for code in ('', None, '688701.SH,600000.SH', '999999.BJ', '000001.SH', 'HK00700', '*'):
with self.subTest(code=code):
result, _, _, factory = self.request(code=code)
self.assertEqual(result['errors'], ['INVALID_REQUEST_CODE'])
factory.assert_not_called()
def test_invalid_date_never_creates_session(self):
for day in (None, True, '2026-02-30', '2026113', '2026-11-03 extra', []):
with self.subTest(day=day):
result, _, _, factory = self.request(day=day)
self.assertEqual(result['errors'], ['INVALID_TARGET_DATE'])
factory.assert_not_called()
def test_missing_token_never_creates_session(self):
for token in ('', ' \n ', None, False, 123):
result, _, _, factory = self.request(token=token)
self.assertEqual(result['errors'], ['MISSING_PROVIDER_TOKEN'])
factory.assert_not_called()
def test_invalid_timeout_never_creates_session(self):
for value in (0, -1, float('nan'), float('inf'), True, 'bad', None):
result, _, _, factory = self.request(timeout_sec=value)
self.assertEqual(result['errors'], ['INVALID_HTTP_TIMEOUT'])
factory.assert_not_called()
def test_short_timeout_caps_connect(self):
_, _, session, _ = self.request(timeout_sec=.25)
timeout = session.calls[0][1]['timeout']
self.assertEqual(timeout.total, .25)
self.assertEqual(timeout.connect_timeout, .25)
def test_redirect_and_http_failure_never_read_body(self):
for status in (301, 302, 307, 401, 429, 500):
result, response, session, _ = self.request(FakeResponse(status=status))
self.assertEqual(result['errors'], ['HTTP_ERROR'])
self.assertEqual(response.reads, 0)
self.assertTrue(response.closed and session.closed)
self.assertEqual(len(session.calls), 1)
def test_provider_error_never_returns_message_or_token(self):
stream = io.StringIO()
with contextlib.redirect_stdout(stream), contextlib.redirect_stderr(stream):
result, _, _, _ = self.request(FakeResponse(payload(code=-2001, msg=TOKEN)))
self.assertEqual(result['errors'], ['PROVIDER_ERROR'])
self.assertNotIn(TOKEN, json.dumps(result)+stream.getvalue())
def test_transport_errors_do_not_echo_details_or_retry(self):
for failure, code in ((provider.requests.exceptions.Timeout(TOKEN), 'HTTP_TIMEOUT'),
(provider.requests.exceptions.ConnectionError(TOKEN), 'HTTP_ERROR'),
(RuntimeError(TOKEN), 'HTTP_ERROR')):
stream = io.StringIO()
with contextlib.redirect_stdout(stream), contextlib.redirect_stderr(stream):
result, _, session, _ = self.request(failure=failure)
self.assertEqual(result['errors'], [code])
self.assertEqual(len(session.calls), 1)
self.assertTrue(session.closed)
self.assertNotIn(TOKEN, json.dumps(result)+stream.getvalue())
def test_stream_timeout_closes_both_resources(self):
result, response, session, _ = self.request(FakeResponse(chunks=[b'{'],
failure=provider.requests.exceptions.ReadTimeout(TOKEN)))
self.assertEqual(result['errors'], ['HTTP_TIMEOUT'])
self.assertTrue(response.closed and session.closed)
def test_requests_wrapped_stream_timeout_is_still_a_timeout(self):
from urllib3.exceptions import ReadTimeoutError
failure = provider.requests.exceptions.ConnectionError(ReadTimeoutError(None, TOKEN, TOKEN))
result, response, session, _ = self.request(FakeResponse(chunks=[b'{'], failure=failure))
self.assertEqual(result['errors'], ['HTTP_TIMEOUT'])
self.assertNotIn(TOKEN, json.dumps(result))
self.assertTrue(response.closed and session.closed)
def test_declared_size_rejects_before_reading(self):
result, response, session, _ = self.request(FakeResponse(headers={'Content-Length': '65537'}))
self.assertEqual(result['errors'], ['RESPONSE_TOO_LARGE'])
self.assertEqual(response.reads, 0)
self.assertTrue(response.closed and session.closed)
def test_stream_limit_applies_without_or_despite_content_length(self):
for headers in ({}, {'Content-Length': '1'}):
result, response, session, _ = self.request(FakeResponse(headers=headers,
chunks=[b' ' * 65536, b'x', b'never-read']))
self.assertEqual(result['errors'], ['RESPONSE_TOO_LARGE'])
self.assertEqual(response.reads, 2)
self.assertTrue(response.closed and session.closed)
def test_exact_size_valid_body_is_accepted(self):
body = json.dumps(payload()).encode()
body += b' ' * (65536-len(body))
result, _, _, _ = self.request(FakeResponse(chunks=[body], headers={'Content-Length': '65536'}))
self.assertEqual(list(result['records']), [CODE])
def test_deadline_after_headers_stops_before_read(self):
result, response, session, _ = self.request(clock=[0., 5.])
self.assertEqual(result['errors'], ['HTTP_TIMEOUT'])
self.assertEqual(response.reads, 0)
self.assertTrue(response.closed and session.closed)
def test_deadline_during_stream_stops_without_more_chunks(self):
result, response, _, _ = self.request(FakeResponse(chunks=[b'{', b'}', b'never-read']),
clock=[0., 1., 2., 5.])
self.assertEqual(result['errors'], ['HTTP_TIMEOUT'])
self.assertEqual(response.reads, 2)
self.assertTrue(response.closed)
def test_invalid_json_and_headers_are_safe(self):
for response in (FakeResponse(chunks=[TOKEN.encode()]), FakeResponse(chunks=[b'\xff']),
FakeResponse(headers={'Content-Length': TOKEN}),
FakeResponse(headers={'Content-Length': '-1'})):
result, response, session, _ = self.request(response)
self.assertEqual(result['errors'], ['INVALID_PROVIDER_RESPONSE'])
self.assertNotIn(TOKEN, json.dumps(result))
self.assertTrue(response.closed and session.closed)
def test_foreign_security_and_wrong_day_are_not_accepted(self):
result, _, _, _ = self.request(FakeResponse(payload([
['600000.SH', '20261103', 10, 11, 9],
[CODE, '20261102', 10, 12, 8],
])))
self.assertEqual(result['records'], {})
self.assertEqual(result['invalid'], {'600000.SH': 'NOT_REQUESTED', CODE: 'DATE_MISMATCH'})
def test_decoder_receives_nonempty_single_code_allowlist(self):
with patch.object(provider.price_limits, 'provider_decode', wraps=provider.price_limits.provider_decode) as decode:
self.request()
self.assertEqual(decode.call_args.kwargs['requested_codes'], [CODE])
def test_environment_proxy_is_not_trusted(self):
with patch.dict(os.environ, {'HTTPS_PROXY': 'https://'+TOKEN, 'NETRC': TOKEN}):
result, _, session, _ = self.request()
self.assertEqual(result['errors'], [])
self.assertFalse(session.calls[0][2])
if __name__ == '__main__':
unittest.main(verbosity=2)