235 lines
11 KiB
Python
235 lines
11 KiB
Python
"""限制价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)
|