| """ |
| Tests for the generic HTTP transport boilerplate. |
| |
| Every test runs against a local loopback server or a closed local port — no public |
| internet. These pin normalized response records, streaming downloads, partial-file |
| hygiene, session reuse, timeout normalization, and genuine async event-loop |
| responsiveness. |
| """ |
|
|
| from __future__ import annotations |
| |
| |
| |
| |
| |
| import asyncio |
| import socket |
| import threading |
| import time |
| from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer |
| from pathlib import Path |
|
|
| import pytest |
| |
| |
| |
| |
| |
| from candlefetcher.util import http |
| from candlefetcher.util.http import HttpResponse, async_download, async_get, sync_download, sync_get |
| |
| |
| |
| |
| |
| _LARGE_BODY = bytes(range(256)) * (1024 * 32) |
|
|
|
|
| class _LoopbackHandler(BaseHTTPRequestHandler): |
|
|
| """ |
| Deterministic loopback server covering success, statuses, delays, and streams. |
| """ |
|
|
| server_version = 'Loopback/1' |
|
|
| def log_message(self, format:str, *args:object) -> None: |
|
|
| """Silence per-request console noise; tests assert on responses, not server logs.""" |
| |
|
|
| def do_GET(self) -> None: |
|
|
| """Serve the fixture selected by the request path.""" |
|
|
| if (self.path == '/text'): |
|
|
| body = 'hello candles'.encode('utf-8') |
|
|
| self.send_response(200) |
| self.send_header('Content-Type', 'text/plain; charset=utf-8') |
| self.send_header('X-Probe-Header', 'probe-value') |
| self.send_header('Content-Length', str(len(body))) |
| self.end_headers() |
| self.wfile.write(body) |
| |
| elif (self.path == '/binary'): |
|
|
| body = bytes(range(256)) * 8 |
|
|
| self.send_response(200) |
| self.send_header('Content-Type', 'application/octet-stream') |
| self.send_header('Content-Length', str(len(body))) |
| self.end_headers() |
| self.wfile.write(body) |
| |
| elif (self.path == '/empty'): |
|
|
| self.send_response(200) |
| self.send_header('Content-Length', '0') |
| self.end_headers() |
| |
| elif (self.path == '/large'): |
|
|
| self.send_response(200) |
| self.send_header('Content-Length', str(len(_LARGE_BODY))) |
| self.end_headers() |
|
|
| for offset in range(0, len(_LARGE_BODY), 64 * 1024): |
|
|
| self.wfile.write(_LARGE_BODY[offset:offset + (64 * 1024)]) |
| |
| |
| elif (self.path == '/slow'): |
|
|
| time.sleep(1.0) |
|
|
| self.send_response(200) |
| self.send_header('Content-Length', '2') |
| self.end_headers() |
| self.wfile.write(b'ok') |
| |
| elif (self.path == '/not-found'): |
|
|
| self.send_response(404) |
| self.send_header('Content-Length', '0') |
| self.end_headers() |
| |
| elif (self.path == '/server-error'): |
|
|
| self.send_response(503) |
| self.send_header('Content-Length', '0') |
| self.end_headers() |
| |
| else: |
|
|
| self.send_response(400) |
| self.send_header('Content-Length', '0') |
| self.end_headers() |
| |
| |
| |
|
|
| @pytest.fixture(scope='module') |
| def loopback_server() -> 'tuple[str, object]': |
|
|
| """Start one shared loopback server for the whole module and yield its base URL.""" |
|
|
| server = ThreadingHTTPServer(('127.0.0.1', 0), _LoopbackHandler) |
| thread = threading.Thread(target=server.serve_forever, daemon=True) |
|
|
| thread.start() |
|
|
| yield (f'http://127.0.0.1:{server.server_address[1]}', server) |
|
|
| server.shutdown() |
| server.server_close() |
| thread.join(timeout=5.0) |
| |
|
|
|
|
| def _closed_port() -> int: |
|
|
| """Reserve one ephemeral port, close it, and return a guaranteed-refused port.""" |
|
|
| probe = socket.socket() |
| probe.bind(('127.0.0.1', 0)) |
|
|
| port = probe.getsockname()[1] |
|
|
| probe.close() |
|
|
| return (port) |
| |
| |
| |
| |
| |
| def test_response_record_helpers() -> None: |
|
|
| """The response record exposes text decoding, ok-ness, and case-insensitive headers.""" |
|
|
| response = HttpResponse( |
| status_code = 200, |
| headers = {'Content-Type': 'text/plain', 'X-MBX-USED-WEIGHT-1M': '118'}, |
| content = 'data'.encode('utf-8'), |
| url = 'http://fixture/x', |
| ) |
|
|
| assert (response.ok) |
| assert (response.text == 'data') |
| assert (response.header('content-type') == 'text/plain') |
| assert (response.header('X-MBX-USED-WEIGHT-1M') == '118') |
| assert (response.header('missing') is None) |
|
|
| failed = HttpResponse(0, {}, b'', 'http://fixture/x', error='connection refused') |
|
|
| assert (not failed.ok) |
| assert (failed.text == '') |
| |
|
|
|
|
| def test_normalize_headers_defaults_user_agent() -> None: |
|
|
| """Header normalization supplies the project user agent when none is given.""" |
|
|
| assert (http._normalize_headers(None) == {'User-Agent': 'CandleFetcher'}) |
| assert (http._normalize_headers({'X-A': '1'}) == {'X-A': '1'}) |
| |
| |
| |
| |
| |
| def test_sync_get_text_success(loopback_server:'tuple[str, object]') -> None: |
|
|
| """Sync GET returns status, headers, and decoded body.""" |
|
|
| base_url, _ = loopback_server |
|
|
| response = sync_get(f'{base_url}/text', timeout=5.0) |
|
|
| assert (response.status_code == 200) |
| assert (response.ok) |
| assert (response.text == 'hello candles') |
| assert (response.header('X-Probe-Header') == 'probe-value') |
| assert (response.url == f'{base_url}/text') |
| |
|
|
|
|
| def test_sync_get_binary_and_empty(loopback_server:'tuple[str, object]') -> None: |
|
|
| """Binary bodies round-trip exactly and empty bodies stay empty.""" |
|
|
| base_url, _ = loopback_server |
|
|
| binary = sync_get(f'{base_url}/binary', timeout=5.0) |
| empty = sync_get(f'{base_url}/empty', timeout=5.0) |
|
|
| assert (binary.content == bytes(range(256)) * 8) |
| assert (empty.status_code == 200) |
| assert (empty.content == b'') |
| |
|
|
|
|
| def test_sync_get_http_error_statuses(loopback_server:'tuple[str, object]') -> None: |
|
|
| """HTTP error statuses become response records, not exceptions.""" |
|
|
| base_url, _ = loopback_server |
|
|
| missing = sync_get(f'{base_url}/not-found', timeout=5.0) |
| broken = sync_get(f'{base_url}/server-error', timeout=5.0) |
|
|
| assert (missing.status_code == 404) |
| assert (not missing.ok) |
| assert (broken.status_code == 503) |
| |
|
|
|
|
| def test_sync_get_connection_refused() -> None: |
|
|
| """Connection failures normalize to a status-0 record with the error text.""" |
|
|
| response = sync_get(f'http://127.0.0.1:{_closed_port()}/x', timeout=2.0) |
|
|
| assert (response.status_code == 0) |
| assert (response.error is not None) |
| assert (not response.ok) |
| assert (response.content == b'') |
| |
|
|
|
|
| def test_sync_get_timeout(loopback_server:'tuple[str, object]') -> None: |
|
|
| """Server delays beyond the timeout normalize to a status-0 record.""" |
|
|
| base_url, _ = loopback_server |
|
|
| response = sync_get(f'{base_url}/slow', timeout=0.2) |
|
|
| assert (response.status_code == 0) |
| assert (response.error is not None) |
| assert ('imeout' in response.error or 'timed out' in response.error.lower()) |
| |
| |
| |
| |
| |
| @pytest.mark.asyncio |
| async def test_async_get_matches_sync_semantics(loopback_server:'tuple[str, object]') -> None: |
|
|
| """Async GET produces the same normalized record shape as sync GET.""" |
|
|
| base_url, _ = loopback_server |
|
|
| response = await async_get(f'{base_url}/text', timeout=5.0) |
|
|
| assert (response.status_code == 200) |
| assert (response.ok) |
| assert (response.text == 'hello candles') |
| assert (response.header('X-Probe-Header') == 'probe-value') |
| |
|
|
|
|
| @pytest.mark.asyncio |
| async def test_async_get_with_reused_session(loopback_server:'tuple[str, object]') -> None: |
|
|
| """A caller-supplied session is reused and never closed by the helper.""" |
|
|
| base_url, _ = loopback_server |
|
|
| async with http.async_session() as session: |
|
|
| first = await async_get(f'{base_url}/text', timeout=5.0, session=session) |
| second = await async_get(f'{base_url}/binary', timeout=5.0, session=session) |
|
|
| assert (first.ok) |
| assert (second.status_code == 200) |
| assert (second.content == bytes(range(256)) * 8) |
| |
| |
|
|
|
|
| @pytest.mark.asyncio |
| async def test_async_get_connection_refused() -> None: |
|
|
| """Async connection failures normalize to the same status-0 record.""" |
|
|
| response = await async_get(f'http://127.0.0.1:{_closed_port()}/x', timeout=2.0) |
|
|
| assert (response.status_code == 0) |
| assert (response.error is not None) |
| assert (not response.ok) |
| |
|
|
|
|
| @pytest.mark.asyncio |
| async def test_async_get_timeout(loopback_server:'tuple[str, object]') -> None: |
|
|
| """Async timeouts normalize to a status-0 record without raising.""" |
|
|
| base_url, _ = loopback_server |
|
|
| response = await async_get(f'{base_url}/slow', timeout=0.2) |
|
|
| assert (response.status_code == 0) |
| assert (response.error is not None) |
| |
|
|
|
|
| @pytest.mark.asyncio |
| async def test_async_get_cancellation_propagates(loopback_server:'tuple[str, object]') -> None: |
|
|
| """Cancelling an in-flight async GET propagates CancelledError to the caller.""" |
|
|
| base_url, _ = loopback_server |
|
|
| task = asyncio.ensure_future(async_get(f'{base_url}/slow', timeout=10.0)) |
|
|
| await asyncio.sleep(0.1) |
|
|
| task.cancel() |
|
|
| with pytest.raises(asyncio.CancelledError): |
|
|
| await task |
| |
| |
|
|
|
|
| @pytest.mark.asyncio |
| async def test_async_get_does_not_block_event_loop(loopback_server:'tuple[str, object]') -> None: |
|
|
| """Waiting on a slow server leaves the loop responsive between heartbeats.""" |
|
|
| base_url, _ = loopback_server |
| heartbeats = 0 |
| max_gap = 0.0 |
| last = time.monotonic() |
|
|
| async def heartbeat() -> None: |
|
|
| nonlocal heartbeats, max_gap, last |
|
|
| for _ in range(30): |
|
|
| await asyncio.sleep(0.01) |
|
|
| current = time.monotonic() |
| max_gap = max(max_gap, current - last) |
| last = current |
| heartbeats += 1 |
| |
| |
|
|
| await asyncio.gather(heartbeat(), async_get(f'{base_url}/slow', timeout=10.0)) |
|
|
| assert (heartbeats == 30) |
| |
| assert (max_gap < 0.5) |
| |
| |
| |
| |
| |
| def test_sync_download_streams_large_file(loopback_server:'tuple[str, object]', tmp_path:Path) -> None: |
|
|
| """Sync streaming downloads write the complete body through the part path.""" |
|
|
| base_url, _ = loopback_server |
| part = tmp_path / 'large.zip.part' |
|
|
| response = sync_download(f'{base_url}/large', part, timeout=30.0) |
|
|
| assert (response.status_code == 200) |
| assert (response.content == b'') |
| assert (part.read_bytes() == _LARGE_BODY) |
| |
|
|
|
|
| def test_sync_download_http_error_removes_partial(loopback_server:'tuple[str, object]', tmp_path:Path) -> None: |
|
|
| """Failed sync downloads never leave a partial file behind.""" |
|
|
| base_url, _ = loopback_server |
| part = tmp_path / 'missing.zip.part' |
|
|
| response = sync_download(f'{base_url}/not-found', part, timeout=5.0) |
|
|
| assert (response.status_code == 404) |
| assert (not part.exists()) |
| |
|
|
|
|
| def test_sync_download_connection_error_removes_partial(tmp_path:Path) -> None: |
|
|
| """Transport failures during sync download clean up their partial file.""" |
|
|
| part = tmp_path / 'refused.zip.part' |
|
|
| response = sync_download(f'http://127.0.0.1:{_closed_port()}/x', part, timeout=2.0) |
|
|
| assert (response.status_code == 0) |
| assert (response.error is not None) |
| assert (not part.exists()) |
| |
| |
| |
| |
| |
| @pytest.mark.asyncio |
| async def test_async_download_streams_large_file(loopback_server:'tuple[str, object]', tmp_path:Path) -> None: |
|
|
| """Async streaming downloads write the complete body with genuine async I/O.""" |
|
|
| base_url, _ = loopback_server |
| part = tmp_path / 'large.zip.part' |
|
|
| response = await async_download(f'{base_url}/large', part, timeout=30.0) |
|
|
| assert (response.status_code == 200) |
| assert (part.read_bytes() == _LARGE_BODY) |
| |
|
|
|
|
| @pytest.mark.asyncio |
| async def test_async_download_http_error_removes_partial(loopback_server:'tuple[str, object]', tmp_path:Path) -> None: |
|
|
| """Failed async downloads never leave a partial file behind.""" |
|
|
| base_url, _ = loopback_server |
| part = tmp_path / 'missing.zip.part' |
|
|
| response = await async_download(f'{base_url}/not-found', part, timeout=5.0) |
|
|
| assert (response.status_code == 404) |
| assert (not part.exists()) |
| |
|
|
|
|
| @pytest.mark.asyncio |
| async def test_async_download_cancellation_removes_partial(loopback_server:'tuple[str, object]', tmp_path:Path) -> None: |
|
|
| """Cancelling mid-download propagates and removes the partial file.""" |
|
|
| base_url, _ = loopback_server |
| part = tmp_path / 'cancelled.zip.part' |
|
|
| task = asyncio.ensure_future(async_download(f'{base_url}/large', part, timeout=30.0)) |
|
|
| await asyncio.sleep(0.05) |
|
|
| task.cancel() |
|
|
| with pytest.raises(asyncio.CancelledError): |
|
|
| await task |
| |
|
|
| await asyncio.sleep(0) |
|
|
| assert (not part.exists()) |
| |
|
|
|
|
| @pytest.mark.asyncio |
| async def test_async_download_does_not_block_event_loop(loopback_server:'tuple[str, object]', tmp_path:Path) -> None: |
|
|
| """Streaming a slow large body keeps the loop responsive throughout.""" |
|
|
| base_url, _ = loopback_server |
| part = tmp_path / 'slow-stream.zip.part' |
| heartbeats = 0 |
| max_gap = 0.0 |
| last = time.monotonic() |
|
|
| async def heartbeat() -> None: |
|
|
| nonlocal heartbeats, max_gap, last |
|
|
| for _ in range(30): |
|
|
| await asyncio.sleep(0.01) |
|
|
| current = time.monotonic() |
| max_gap = max(max_gap, current - last) |
| last = current |
| heartbeats += 1 |
| |
| |
|
|
| await asyncio.gather(heartbeat(), async_download(f'{base_url}/large', part, timeout=30.0)) |
|
|
| assert (heartbeats == 30) |
| assert (max_gap < 0.5) |
| assert (part.read_bytes() == _LARGE_BODY) |
| |
|
|
|
|
| @pytest.mark.asyncio |
| async def test_async_download_with_reused_session(loopback_server:'tuple[str, object]', tmp_path:Path) -> None: |
|
|
| """Downloads accept a caller-supplied session and leave it open for reuse.""" |
|
|
| base_url, _ = loopback_server |
| part = tmp_path / 'session.zip.part' |
|
|
| async with http.async_session() as session: |
|
|
| response = await async_download(f'{base_url}/binary', part, timeout=10.0, session=session) |
|
|
| follow_up = await session.get(f'{base_url}/text', timeout=5.0) |
|
|
| assert (response.status_code == 200) |
| assert (part.read_bytes() == bytes(range(256)) * 8) |
| assert (follow_up.status_code == 200) |
| |
| |
| |
| |
| |
| |
|
|
