| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import socket |
| import threading |
| import time |
| from concurrent.futures import ThreadPoolExecutor |
| from http.client import HTTPResponse |
| from urllib.parse import urlsplit |
| from urllib.error import HTTPError |
| from urllib.request import Request, urlopen |
|
|
| import pytest |
|
|
| from scripts import ctx_ab_deterministic_bridge as bridge |
|
|
|
|
| APPROVAL_DIGEST = hashlib.sha256(b"reviewed deterministic bridge config").hexdigest() |
| REQUEST_BYTES = b'{"model":"ctx-deterministic","messages":[{"role":"user","content":"abcd"}]}' |
|
|
|
|
| def _request( |
| server: bridge.DeterministicProviderBridge, |
| body: bytes = REQUEST_BYTES, |
| *, |
| approval_digest: str = APPROVAL_DIGEST, |
| path: str = "/v1/chat/completions", |
| content_type: str = "application/json", |
| ) -> tuple[int, bytes]: |
| request = Request( |
| f"{server.base_url}{path}", |
| data=body, |
| method="POST", |
| headers={ |
| "Content-Type": content_type, |
| bridge.APPROVAL_DIGEST_HEADER: approval_digest, |
| }, |
| ) |
| try: |
| response: HTTPResponse = urlopen(request, timeout=2) |
| except HTTPError as error: |
| return error.code, error.read() |
| with response: |
| return response.status, response.read() |
|
|
|
|
| def _raw_request( |
| server: bridge.DeterministicProviderBridge, |
| request_bytes: bytes, |
| ) -> tuple[int, dict[str, object]]: |
| endpoint = urlsplit(server.base_url) |
| assert endpoint.hostname is not None |
| assert endpoint.port is not None |
| with socket.create_connection((endpoint.hostname, endpoint.port), timeout=2) as connection: |
| connection.sendall(request_bytes) |
| connection.shutdown(socket.SHUT_WR) |
| chunks: list[bytes] = [] |
| while chunk := connection.recv(65_536): |
| chunks.append(chunk) |
|
|
| response = b"".join(chunks) |
| head, body = response.split(b"\r\n\r\n", 1) |
| status = int(head.split(b" ", 2)[1]) |
| payload = json.loads(body) |
| assert isinstance(payload, dict) |
| return status, payload |
|
|
|
|
| def test_bridge_returns_repeatable_openai_response_and_exact_record() -> None: |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=20, |
| response_content="done", |
| ) as server: |
| first_status, first_bytes = _request(server) |
| second_status, second_bytes = _request(server) |
|
|
| records = server.records |
|
|
| assert (first_status, second_status) == (200, 200) |
| assert first_bytes == second_bytes |
| response = json.loads(first_bytes) |
| assert response["choices"] == [ |
| { |
| "finish_reason": "stop", |
| "index": 0, |
| "message": {"content": "done", "role": "assistant"}, |
| } |
| ] |
| assert response["usage"] == { |
| "cached_input_tokens": 0, |
| "completion_tokens": 1, |
| "input_tokens": 19, |
| "output_tokens": 1, |
| "prompt_tokens": 19, |
| "prompt_tokens_details": {"cached_tokens": 0}, |
| "total_tokens": 20, |
| "uncached_input_tokens": 19, |
| } |
| assert len(records) == 2 |
| assert records[0].request_body_bytes == REQUEST_BYTES |
| assert records[0].request_body_sha256 == hashlib.sha256(REQUEST_BYTES).hexdigest() |
| assert records[0].method == "POST" |
| assert records[0].path == "/v1/chat/completions" |
| assert records[0].response_status == 200 |
| assert records[0].approval_digest == APPROVAL_DIGEST |
| assert records[0].messages == (bridge.CapturedMessage(role="user", content="abcd"),) |
| assert records[0].usage == bridge.TokenUsage( |
| input_tokens=19, |
| cached_input_tokens=0, |
| uncached_input_tokens=19, |
| output_tokens=1, |
| total_tokens=20, |
| ) |
|
|
|
|
| def test_bridge_rejects_unapproved_or_missing_digest_without_recording() -> None: |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ) as server: |
| mismatch_status, mismatch_body = _request(server, approval_digest="0" * 64) |
| missing = Request( |
| f"{server.base_url}/v1/chat/completions", |
| data=REQUEST_BYTES, |
| method="POST", |
| headers={"Content-Type": "application/json"}, |
| ) |
| with pytest.raises(HTTPError) as missing_error: |
| urlopen(missing, timeout=2) |
| bearer_mismatch = Request( |
| f"{server.base_url}/v1/chat/completions", |
| data=REQUEST_BYTES, |
| method="POST", |
| headers={ |
| "Authorization": f"Bearer {'0' * 64}", |
| "Content-Type": "application/json", |
| }, |
| ) |
| with pytest.raises(HTTPError) as bearer_mismatch_error: |
| urlopen(bearer_mismatch, timeout=2) |
| records = server.records |
|
|
| assert mismatch_status == 403 |
| assert json.loads(mismatch_body)["error"]["code"] == "approval_digest_mismatch" |
| assert missing_error.value.code == 403 |
| assert bearer_mismatch_error.value.code == 403 |
| assert records == () |
|
|
|
|
| def test_bridge_accepts_approval_digest_as_openai_bearer_api_key() -> None: |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ) as server: |
| request = Request( |
| f"{server.base_url}/v1/chat/completions", |
| data=REQUEST_BYTES, |
| method="POST", |
| headers={ |
| "Authorization": f"Bearer {APPROVAL_DIGEST}", |
| "Content-Type": "application/json", |
| }, |
| ) |
| with urlopen(request, timeout=2) as response: |
| status = response.status |
| records = server.records |
|
|
| assert status == 200 |
| assert len(records) == 1 |
| assert records[0].approval_digest == APPROVAL_DIGEST |
|
|
|
|
| def test_bridge_enforces_configured_and_request_output_token_budgets() -> None: |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=19, |
| response_content="done", |
| ) as server: |
| status, body = _request(server) |
| configured_records = server.records |
|
|
| output_limited = ( |
| b'{"model":"ctx-deterministic","max_tokens":1,"messages":' |
| b'[{"role":"user","content":"abcd"}]}' |
| ) |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| response_content="12345", |
| ) as server: |
| limited_status, limited_body = _request(server, output_limited) |
| limited_records = server.records |
|
|
| assert status == 413 |
| assert json.loads(body)["error"]["code"] == "token_budget_exceeded" |
| assert configured_records == () |
| assert limited_status == 413 |
| assert json.loads(limited_body)["error"]["code"] == "request_output_budget_exceeded" |
| assert limited_records == () |
|
|
|
|
| @pytest.mark.parametrize( |
| ("body", "content_type", "error_code"), |
| [ |
| (b"{", "application/json", "malformed_json"), |
| ( |
| b'{"model":"one","model":"two","messages":[]}', |
| "application/json", |
| "malformed_json", |
| ), |
| (b"[]", "application/json", "invalid_request"), |
| ( |
| b'{"model":"ctx-deterministic","messages":[],"stream":true}', |
| "application/json", |
| "streaming_not_supported", |
| ), |
| (REQUEST_BYTES, "text/plain", "unsupported_media_type"), |
| ], |
| ) |
| def test_bridge_rejects_malformed_requests( |
| body: bytes, |
| content_type: str, |
| error_code: str, |
| ) -> None: |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ) as server: |
| status, response_body = _request(server, body, content_type=content_type) |
|
|
| assert status in {400, 415, 422} |
| assert json.loads(response_body)["error"]["code"] == error_code |
|
|
|
|
| def test_bridge_rejects_unknown_paths_and_non_loopback_bind() -> None: |
| with pytest.raises(ValueError, match="loopback"): |
| bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| bind_host="0.0.0.0", |
| ) |
|
|
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ) as server: |
| status, response_body = _request(server, path="/not-an-api") |
|
|
| assert status == 404 |
| assert json.loads(response_body)["error"]["code"] == "unknown_path" |
|
|
|
|
| @pytest.mark.parametrize( |
| "request_target", |
| [ |
| b"http://[invalid/v1/chat/completions", |
| b"http://127.0.0.1/v1/chat/completions", |
| b"//127.0.0.1/v1/chat/completions", |
| ], |
| ids=["invalid-absolute-uri", "absolute-form", "network-form"], |
| ) |
| def test_bridge_accepts_only_exact_origin_form_request_target(request_target: bytes) -> None: |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ) as server: |
| status, response = _raw_request( |
| server, |
| b"POST " |
| + request_target |
| + b" HTTP/1.1\r\nHost: 127.0.0.1\r\n" |
| + bridge.APPROVAL_DIGEST_HEADER.encode("ascii") |
| + b": " |
| + APPROVAL_DIGEST.encode("ascii") |
| + b"\r\nContent-Type: application/json\r\nContent-Length: " |
| + str(len(REQUEST_BYTES)).encode("ascii") |
| + b"\r\n\r\n" |
| + REQUEST_BYTES, |
| ) |
|
|
| assert status in {400, 404} |
| assert response["error"]["code"] in { |
| "invalid_request_target", |
| "unknown_path", |
| } |
|
|
|
|
| @pytest.mark.parametrize( |
| "content_length", |
| [b"\xff", b"9" * 5_000], |
| ids=["non-ascii", "absurd-decimal-length"], |
| ) |
| def test_bridge_bounds_pathological_content_length(content_length: bytes) -> None: |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ) as server: |
| status, response = _raw_request( |
| server, |
| b"POST /v1/chat/completions HTTP/1.1\r\n" |
| b"Host: 127.0.0.1\r\n" |
| + bridge.APPROVAL_DIGEST_HEADER.encode("ascii") |
| + b": " |
| + APPROVAL_DIGEST.encode("ascii") |
| + b"\r\nContent-Type: application/json\r\nContent-Length: " |
| + content_length |
| + b"\r\n\r\n", |
| ) |
|
|
| assert status == 400 |
| assert response["error"]["code"] == "invalid_content_length" |
|
|
|
|
| @pytest.mark.parametrize("header_name", [bridge.APPROVAL_DIGEST_HEADER, "Authorization"]) |
| def test_bridge_bounds_non_ascii_approval_headers(header_name: str) -> None: |
| header_value = b"Bearer \xff" if header_name == "Authorization" else b"\xff" |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ) as server: |
| status, response = _raw_request( |
| server, |
| b"POST /v1/chat/completions HTTP/1.1\r\nHost: 127.0.0.1\r\n" |
| + header_name.encode("ascii") |
| + b": " |
| + header_value |
| + b"\r\nContent-Type: application/json\r\nContent-Length: " |
| + str(len(REQUEST_BYTES)).encode("ascii") |
| + b"\r\n\r\n" |
| + REQUEST_BYTES, |
| ) |
|
|
| assert status == 403 |
| assert response["error"]["code"] == "approval_digest_mismatch" |
|
|
|
|
| def test_bridge_catch_all_returns_bounded_json( |
| monkeypatch: pytest.MonkeyPatch, |
| ) -> None: |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ) as server: |
| monkeypatch.setattr( |
| server, |
| "_handle_post", |
| lambda _handler: (_ for _ in ()).throw(RuntimeError("private details")), |
| ) |
| status, response = _raw_request( |
| server, |
| b"POST /v1/chat/completions HTTP/1.1\r\nHost: 127.0.0.1\r\nContent-Length: 0\r\n\r\n", |
| ) |
|
|
| assert status == 400 |
| assert response == { |
| "error": { |
| "code": "malformed_request", |
| "message": "request could not be processed", |
| "type": "invalid_request_error", |
| } |
| } |
|
|
|
|
| def test_bridge_records_parallel_requests_without_losing_evidence() -> None: |
| with bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ) as server: |
| with ThreadPoolExecutor(max_workers=8) as executor: |
| results = tuple(executor.map(lambda _: _request(server), range(32))) |
| records = server.records |
|
|
| assert {status for status, _ in results} == {200} |
| assert len(records) == 32 |
| assert {record.request_body_sha256 for record in records} == { |
| hashlib.sha256(REQUEST_BYTES).hexdigest() |
| } |
|
|
|
|
| def test_bridge_is_terminally_closed_and_does_not_mix_lifetimes() -> None: |
| server = bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ).start() |
| assert _request(server)[0] == 200 |
|
|
| server.close() |
| server.close() |
|
|
| assert len(server.records) == 1 |
| with pytest.raises(RuntimeError, match="closed"): |
| server.start() |
| with pytest.raises(RuntimeError, match="not running"): |
| _ = server.base_url |
|
|
|
|
| def test_start_failure_closes_bound_socket_and_is_terminal( |
| monkeypatch: pytest.MonkeyPatch, |
| ) -> None: |
| server = bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ) |
| bound_ports: list[int] = [] |
|
|
| def fail_start(_thread: threading.Thread) -> None: |
| underlying = server._server |
| assert underlying is not None |
| bound_ports.append(underlying.server_port) |
| raise RuntimeError("injected start failure") |
|
|
| monkeypatch.setattr(bridge.threading.Thread, "start", fail_start) |
| with pytest.raises(RuntimeError, match="injected start failure"): |
| server.start() |
|
|
| assert len(bound_ports) == 1 |
| with socket.socket() as probe: |
| probe.bind(("127.0.0.1", bound_ports[0])) |
| with pytest.raises(RuntimeError, match="closed"): |
| server.start() |
| with pytest.raises(RuntimeError, match="not running"): |
| _ = server.base_url |
| server.close() |
|
|
|
|
| def test_bridge_rejects_start_while_close_is_in_progress( |
| monkeypatch: pytest.MonkeyPatch, |
| ) -> None: |
| server = bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ).start() |
| underlying = server._server |
| assert underlying is not None |
| shutdown_entered = threading.Event() |
| allow_shutdown = threading.Event() |
| original_shutdown = underlying.shutdown |
|
|
| def blocking_shutdown() -> None: |
| shutdown_entered.set() |
| assert allow_shutdown.wait(timeout=2) |
| original_shutdown() |
|
|
| monkeypatch.setattr(underlying, "shutdown", blocking_shutdown) |
| close_thread = threading.Thread(target=server.close) |
| close_thread.start() |
| assert shutdown_entered.wait(timeout=2) |
| try: |
| with pytest.raises(RuntimeError, match="closing"): |
| server.start() |
| finally: |
| allow_shutdown.set() |
| close_thread.join(timeout=3) |
|
|
| assert not close_thread.is_alive() |
| with pytest.raises(RuntimeError, match="closed"): |
| server.start() |
|
|
|
|
| def test_close_terminates_partial_request_before_freezing_records() -> None: |
| server = bridge.DeterministicProviderBridge( |
| approval_digest=APPROVAL_DIGEST, |
| token_budget=100, |
| ).start() |
| endpoint = urlsplit(server.base_url) |
| assert endpoint.hostname is not None |
| assert endpoint.port is not None |
| connection = socket.create_connection((endpoint.hostname, endpoint.port), timeout=2) |
| partial_body = REQUEST_BYTES[:10] |
| connection.sendall( |
| b"POST /v1/chat/completions HTTP/1.1\r\nHost: 127.0.0.1\r\n" |
| + bridge.APPROVAL_DIGEST_HEADER.encode("ascii") |
| + b": " |
| + APPROVAL_DIGEST.encode("ascii") |
| + b"\r\nContent-Type: application/json\r\nContent-Length: " |
| + str(len(REQUEST_BYTES)).encode("ascii") |
| + b"\r\n\r\n" |
| + partial_body |
| ) |
| time.sleep(0.05) |
|
|
| close_started = time.monotonic() |
| server.close() |
| close_elapsed = time.monotonic() - close_started |
| frozen_records = server.records |
| try: |
| connection.sendall(REQUEST_BYTES[len(partial_body) :]) |
| except OSError: |
| pass |
| connection.settimeout(0.2) |
| received = b"" |
| try: |
| while chunk := connection.recv(65_536): |
| received += chunk |
| except OSError: |
| pass |
| finally: |
| connection.close() |
| time.sleep(0.05) |
|
|
| assert close_elapsed < 2 |
| assert b" 200 " not in received |
| assert frozen_records == () |
| assert server.records == frozen_records |
|
|
|
|
| @pytest.mark.parametrize("bad_digest", ["", "A" * 64, "x" * 64, "0" * 63]) |
| def test_bridge_rejects_invalid_config_digest(bad_digest: str) -> None: |
| with pytest.raises(ValueError, match="approval_digest"): |
| bridge.DeterministicProviderBridge( |
| approval_digest=bad_digest, |
| token_budget=100, |
| ) |
|
|
