tradingSystem/scripts/test_price_limit_provider.py

235 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.

"""限制价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)