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