| from __future__ import annotations |
|
|
| import copy |
| import hashlib |
| import pickle |
| import sqlite3 |
| from concurrent.futures import ThreadPoolExecutor |
| from dataclasses import replace |
| from pathlib import Path |
|
|
| import pytest |
|
|
| from ctx.engine.content import PreparedCapabilityContent |
| from ctx.engine.engine import _PromptContextReceiptPermit |
| from ctx.engine.protocol import Transition |
| from ctx.engine.replay import ReplayInput |
| from ctx.runtime.prepared_query_delivery import ( |
| PreparedQueryDelivery, |
| PreparedQueryDeliveryError, |
| _create_prepared_query_delivery, |
| accept_prepared_query_delivery, |
| ) |
| from ctx.runtime.query_decision import QueryHostDescriptor |
| from ctx.runtime.query_session import prepare_query_delivery |
|
|
|
|
| def _delivery(tmp_path: Path) -> PreparedQueryDelivery: |
| result = prepare_query_delivery( |
| host=QueryHostDescriptor.codex("activate"), |
| task="Fix the Python tests", |
| language="python", |
| session_id="prepared-delivery-test", |
| workspace=tmp_path, |
| journal_path=tmp_path / "engine.sqlite3", |
| benefit_audit_path=tmp_path / "benefit.sqlite3", |
| host_invocation_digest=hashlib.sha256(b"host-invocation").hexdigest(), |
| ) |
| assert isinstance(result, PreparedQueryDelivery) |
| return result |
|
|
|
|
| def test_prepared_query_delivery_accepts_a_defensive_exact_copy(tmp_path: Path) -> None: |
| original = _delivery(tmp_path) |
|
|
| accepted = accept_prepared_query_delivery( |
| original, |
| host=QueryHostDescriptor.codex("activate"), |
| ) |
|
|
| assert accepted is not original |
| assert accepted.delivery_digest == original.delivery_digest |
| assert accepted.context == original.context |
| assert repr(accepted) == ( |
| f"PreparedQueryDelivery(delivery_digest={accepted.delivery_digest!r})" |
| ) |
| assert "# ctx Python Testing" not in repr(accepted) |
| with pytest.raises(PreparedQueryDeliveryError, match="already accepted"): |
| accept_prepared_query_delivery( |
| original, |
| host=QueryHostDescriptor.codex("activate"), |
| ) |
| with pytest.raises(PreparedQueryDeliveryError, match="already accepted"): |
| accept_prepared_query_delivery( |
| accepted, |
| host=QueryHostDescriptor.codex("activate"), |
| ) |
|
|
|
|
| @pytest.mark.parametrize( |
| "host", |
| [ |
| QueryHostDescriptor.claude_code("activate"), |
| QueryHostDescriptor.codex("experiment"), |
| QueryHostDescriptor.codex(), |
| ], |
| ) |
| def test_prepared_query_delivery_rejects_wrong_host_or_intent( |
| tmp_path: Path, |
| host: QueryHostDescriptor, |
| ) -> None: |
| delivery = _delivery(tmp_path) |
|
|
| with pytest.raises(PreparedQueryDeliveryError): |
| accept_prepared_query_delivery(delivery, host=host) |
|
|
|
|
| @pytest.mark.parametrize( |
| ("field_name", "replacement"), |
| [ |
| ("context", "substituted material"), |
| ("context_sha256", hashlib.sha256(b"substituted").hexdigest()), |
| ("final_journal_record_digest", hashlib.sha256(b"other journal").hexdigest()), |
| ("action_content_digest", hashlib.sha256(b"other action").hexdigest()), |
| ], |
| ) |
| def test_prepared_query_delivery_rejects_substitution( |
| tmp_path: Path, |
| field_name: str, |
| replacement: str, |
| ) -> None: |
| original = _delivery(tmp_path) |
|
|
| with pytest.raises(PreparedQueryDeliveryError): |
| replace(original, **{field_name: replacement}) |
|
|
|
|
| def test_prepared_query_delivery_rejects_copy_and_serialization(tmp_path: Path) -> None: |
| delivery = _delivery(tmp_path) |
|
|
| with pytest.raises(TypeError): |
| copy.copy(delivery) |
| with pytest.raises(TypeError): |
| copy.deepcopy(delivery) |
| with pytest.raises(TypeError): |
| pickle.dumps(delivery) |
|
|
|
|
| def test_prepared_query_delivery_rejects_a_forged_engine_receipt_permit( |
| tmp_path: Path, |
| ) -> None: |
| delivery = _delivery(tmp_path) |
| with sqlite3.connect(tmp_path / "engine.sqlite3") as connection: |
| rev2 = Transition.from_json( |
| connection.execute( |
| "SELECT transition_json FROM engine_journal WHERE revision = 2" |
| ).fetchone()[0] |
| ) |
| replay3 = ReplayInput.from_json( |
| connection.execute( |
| "SELECT replay_json FROM engine_journal WHERE revision = 3" |
| ).fetchone()[0] |
| ) |
| action = next(item for item in rev2.actions if item.kind == "PreparePromptContext") |
| metadata = delivery.capabilities[0] |
| raw_content = delivery.context.split(">\n", 1)[1].rsplit( |
| "\n</ctx-capability>", |
| 1, |
| )[0] |
| content = PreparedCapabilityContent( |
| capability_id=metadata.capability_id, |
| source_digest=metadata.source_digest, |
| catalog_snapshot_digest=action.catalog_snapshot_id or "", |
| action_id=action.action_id, |
| lease_id=action.lease_id or "", |
| content=raw_content, |
| content_sha256=metadata.content_sha256, |
| content_bytes=metadata.content_bytes, |
| estimated_tokens=metadata.estimated_tokens, |
| ) |
| forged_permit = object.__new__(_PromptContextReceiptPermit) |
|
|
| with pytest.raises( |
| PreparedQueryDeliveryError, |
| match="authoritative revision-three receipt", |
| ): |
| _create_prepared_query_delivery( |
| decision=delivery.decision, |
| execution_intent="activate", |
| action=action, |
| receipt_event=replay3.reducer_event, |
| contents=(content,), |
| receipt_authority=forged_permit, |
| ) |
|
|
| malicious_body = "arbitrary caller-supplied prompt instructions" |
| malicious = replace( |
| content, |
| content=malicious_body, |
| content_sha256=hashlib.sha256(malicious_body.encode()).hexdigest(), |
| content_bytes=len(malicious_body.encode()), |
| ) |
| with pytest.raises(PreparedQueryDeliveryError, match="changed authorized material"): |
| _create_prepared_query_delivery( |
| decision=delivery.decision, |
| execution_intent="activate", |
| action=action, |
| receipt_event=replay3.reducer_event, |
| contents=(malicious,), |
| receipt_authority=forged_permit, |
| ) |
|
|
| with pytest.raises(TypeError, match="final_journal_record_digest"): |
| _create_prepared_query_delivery( |
| decision=delivery.decision, |
| execution_intent="activate", |
| action=action, |
| receipt_event=replay3.reducer_event, |
| contents=(content,), |
| receipt_authority=forged_permit, |
| final_journal_record_digest=hashlib.sha256(b"fake final record").hexdigest(), |
| ) |
|
|
|
|
| def test_prepared_query_delivery_acceptance_is_concurrently_one_shot( |
| tmp_path: Path, |
| ) -> None: |
| delivery = _delivery(tmp_path) |
| host = QueryHostDescriptor.codex("activate") |
|
|
| def accept_once() -> str: |
| try: |
| accept_prepared_query_delivery(delivery, host=host) |
| except PreparedQueryDeliveryError: |
| return "rejected" |
| return "accepted" |
|
|
| with ThreadPoolExecutor(max_workers=16) as executor: |
| outcomes = tuple(executor.map(lambda _index: accept_once(), range(64))) |
|
|
| assert outcomes.count("accepted") == 1 |
| assert outcomes.count("rejected") == 63 |
|
|
