from __future__ import annotations import asyncio import base64 import hashlib import json import os import subprocess from collections.abc import AsyncIterator from datetime import date from decimal import Decimal from pathlib import Path from types import SimpleNamespace import pytest from microstructure import cli as cli_module from microstructure.cli import main from microstructure.data.binance import CapturedDepth, RawDepthFrame from microstructure.data.book import BookSnapshot, DepthDelta from microstructure.data.storage import write_source_manifest from microstructure.m8_acquisition import M8AcquisitionFailureResult from microstructure.m8_l2_capture import M8L2VerificationError from microstructure.provenance import read_json, sha256_file, utc_now_iso PROJECT_ROOT = Path(__file__).parents[1] def _captured_depth( *, sequence: int, continuity_id: str, event_ts_ns: int, ) -> CapturedDepth: raw_payload = json.dumps( {"continuity_id": continuity_id, "sequence": sequence}, separators=(",", ":"), ) return CapturedDepth( raw_payload=raw_payload, delta=DepthDelta( venue="binance_spot", symbol="BTCUSDT", event_ts_ns=event_ts_ns, received_ts_ns=event_ts_ns + 100, available_ts_ns=event_ts_ns + 100, availability_basis="local_receive_time", capture_seq=sequence, continuity_id=continuity_id, first_update_id=sequence, last_update_id=sequence, previous_update_id=sequence - 1, bids=((10_000, 10 + sequence),), asks=(), tick_size=0.01, lot_size=0.001, source_artifact_id=hashlib.sha256(raw_payload.encode()).hexdigest(), ), ) def _preserved_snapshot( *, output_root: Path, continuity_id: str, last_update_id: int, received_ts_ns: int, ) -> BookSnapshot: payload = json.dumps( { "asks": [["100.02", "0.010"]], "bids": [["100.00", "0.010"]], "lastUpdateId": last_update_id, }, separators=(",", ":"), sort_keys=True, ).encode() digest = hashlib.sha256(payload).hexdigest() raw_path = ( output_root / "raw" / "binance_spot" / "depth_snapshots" / "BTCUSDT" / f"{digest}.json" ) raw_path.parent.mkdir(parents=True, exist_ok=True) raw_path.write_bytes(payload) write_source_manifest( raw_path, source="binance_spot_public_api", source_uri="https://example.invalid/api/v3/depth", downloaded_at_utc=utc_now_iso(), requested_start_ns=None, requested_end_ns=None, ) return BookSnapshot( venue="binance_spot", symbol="BTCUSDT", snapshot_id=digest, request_ts_ns=received_ts_ns - 100, received_ts_ns=received_ts_ns, available_ts_ns=received_ts_ns, continuity_id=continuity_id, last_update_id=last_update_id, depth_limit=100, bids=((10_000, 10),), asks=((10_002, 10),), tick_size=0.01, lot_size=0.001, source_artifact_id=digest, ) def test_cli_help_and_version_are_available(capsys: object) -> None: try: main(["--help"]) except SystemExit as error: assert error.code == 0 def test_validate_command_runs_offline(capsys: object) -> None: exit_code = main(["validate", "--config", str(PROJECT_ROOT / "configs" / "smoke.toml")]) assert exit_code == 0 def _mock_m8_config(*, allow_quality_warnings: bool = False) -> SimpleNamespace: return SimpleNamespace( periods=(SimpleNamespace(), SimpleNamespace()), study=SimpleNamespace( symbols=("BTCUSDT", "ETHUSDT"), evidence_tier="FULL_DATA", ), quality=SimpleNamespace(allow_quality_warnings=allow_quality_warnings), ) def test_acquire_m8_command_prints_raw_only_authority_and_propagates_paths( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: config_path = tmp_path / "study.toml" output_root = tmp_path / "m8-data" manifest_path = output_root / "_manifests" / "m8-acquisition.manifest-aaaaaaaa.json" digest = "a" * 64 config = _mock_m8_config() result = SimpleNamespace( output_root=output_root.resolve(), manifest_path=manifest_path, manifest_sha256=digest, metadata_count=2, archive_count=8, total_raw_evidence_bytes=12_345, ) calls: list[tuple[object, Path]] = [] def fake_load(path: Path) -> object: assert path == config_path return config def fake_acquire(loaded: object, destination: Path) -> object: calls.append((loaded, destination)) return result monkeypatch.setattr(cli_module, "load_m8_config", fake_load) monkeypatch.setattr(cli_module, "acquire_m8_archives", fake_acquire) exit_code = main( [ "acquire-m8", "--config", str(config_path), "--output-root", str(output_root), ] ) assert exit_code == 0 assert calls == [(config, output_root.resolve())] assert json.loads(capsys.readouterr().out) == { "archives": 8, "csv_members_opened": False, "economic_fields_inspected": False, "metadata_responses": 2, "output_root": str(output_root.resolve()), "raw_manifest": str(manifest_path), "raw_manifest_sha256": digest, "scope": "raw_only", "status": "acquired", "total_raw_evidence_bytes": 12_345, } def test_acquire_m8_failure_is_reported_with_error_exit_code( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: monkeypatch.setattr(cli_module, "load_m8_config", lambda path: _mock_m8_config()) def fail_acquisition(config: object, root: Path) -> object: raise RuntimeError("archive authentication failed") monkeypatch.setattr(cli_module, "acquire_m8_archives", fail_acquisition) exit_code = main( [ "acquire-m8", "--config", str(tmp_path / "study.toml"), "--output-root", str(tmp_path / "data"), ] ) assert exit_code == 2 assert capsys.readouterr().err == "error: archive authentication failed\n" def test_acquire_m8_deterministic_failure_prints_json_and_exits_one( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: output_root = tmp_path / "data" attempt_dir = output_root / "_attempts" / f"m8-acquisition-attempt-{'a' * 20}" result = M8AcquisitionFailureResult( output_root=output_root, attempt_dir=attempt_dir, attempt_manifest_path=attempt_dir / "failure.json", attempt_manifest_sha256="a" * 64, checksums_path=attempt_dir / "checksums.sha256", checksums_sha256="b" * 64, terminal_path=attempt_dir / "INSUFFICIENT_DATA", reason_code="DECLARED_OBJECT_UNAVAILABLE", diagnostic="BinanceArchiveHTTPError: HTTP 404", failed_symbol="BTCUSDT", failed_date=date(2024, 1, 3), failed_role="train", completed_count=2, remaining_count=7, retained_inventory_sha256="c" * 64, retained_artifact_count=6, total_raw_evidence_bytes=1_234, manifest=None, # type: ignore[arg-type] ) monkeypatch.setattr(cli_module, "load_m8_config", lambda path: _mock_m8_config()) monkeypatch.setattr(cli_module, "acquire_m8_archives", lambda config, root: result) exit_code = main( [ "acquire-m8", "--config", str(tmp_path / "study.toml"), "--output-root", str(output_root), ] ) assert exit_code == 1 payload = json.loads(capsys.readouterr().out) assert payload["status"] == "INSUFFICIENT_DATA" assert payload["reason_code"] == "DECLARED_OBJECT_UNAVAILABLE" assert payload["failed_symbol"] == "BTCUSDT" assert payload["failed_date"] == "2024-01-03" assert payload["failure_manifest_sha256"] == "a" * 64 assert payload["retained_inventory_sha256"] == "c" * 64 assert payload["csv_members_opened"] is False def test_reproduce_m8_propagates_explicit_manifest_coordinates_exactly( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: config_path = tmp_path / "study.toml" run_dir = tmp_path / "run" manifest_path = tmp_path / "data" / "_manifests" / "input.json" digest = "0123456789abcdef" * 4 config = _mock_m8_config() calls: list[tuple[object, Path, Path, str]] = [] def fake_reproduce( loaded: object, destination: Path, *, raw_manifest_path: Path, raw_manifest_sha256: str, ) -> SimpleNamespace: calls.append((loaded, destination, raw_manifest_path, raw_manifest_sha256)) return SimpleNamespace( path=run_dir, status="COMPLETE", raw_manifest_sha256=raw_manifest_sha256, normalized_manifest_sha256="f" * 64, ) bundle = SimpleNamespace( run_id="m8-unit", evidence_tier="FULL_DATA", observed_start_utc="2024-01-03T00:00:00Z", observed_end_utc="2024-01-06T23:59:59Z", ) monkeypatch.setattr(cli_module, "load_m8_config", lambda path: config) monkeypatch.setattr(cli_module, "reproduce_m8", fake_reproduce) monkeypatch.setattr(cli_module, "load_run_bundle", lambda path: bundle) exit_code = main( [ "reproduce-m8", "--config", str(config_path), "--run-dir", str(run_dir), "--raw-manifest", str(manifest_path), "--raw-manifest-sha256", digest, ] ) assert exit_code == 0 assert calls == [(config, run_dir, manifest_path, digest)] assert json.loads(capsys.readouterr().out) == { "evidence_tier": "FULL_DATA", "observed_end_utc": "2024-01-06T23:59:59Z", "observed_start_utc": "2024-01-03T00:00:00Z", "normalized_manifest_sha256": "f" * 64, "raw_manifest_sha256": digest, "run_dir": str(run_dir), "run_id": "m8-unit", "status": "COMPLETE", } def test_reproduce_m8_producer_failure_uses_error_exit_code( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: monkeypatch.setattr(cli_module, "load_m8_config", lambda path: _mock_m8_config()) def fail_producer(*args: object, **kwargs: object) -> Path: raise RuntimeError("locked production failed") monkeypatch.setattr(cli_module, "reproduce_m8", fail_producer) exit_code = main( [ "reproduce-m8", "--config", str(tmp_path / "study.toml"), "--run-dir", str(tmp_path / "run"), "--raw-manifest", str(tmp_path / "input.json"), "--raw-manifest-sha256", "c" * 64, ] ) assert exit_code == 2 assert capsys.readouterr().err == "error: locked production failed\n" def test_reproduce_m8_preserves_verified_insufficient_data_status( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: digest = "d" * 64 run_dir = tmp_path / "run" monkeypatch.setattr(cli_module, "load_m8_config", lambda path: _mock_m8_config()) monkeypatch.setattr( cli_module, "reproduce_m8", lambda *args, **kwargs: SimpleNamespace( path=run_dir, status="INSUFFICIENT_DATA", raw_manifest_sha256=digest, normalized_manifest_sha256=None, ), ) monkeypatch.setattr( cli_module, "load_run_bundle", lambda path: pytest.fail("an insufficient-data result is not a complete run bundle"), ) exit_code = main( [ "reproduce-m8", "--config", str(tmp_path / "study.toml"), "--run-dir", str(run_dir), "--raw-manifest", str(tmp_path / "raw.json"), "--raw-manifest-sha256", digest, ] ) assert exit_code == 1 assert json.loads(capsys.readouterr().out) == { "normalized_manifest_sha256": None, "raw_manifest_sha256": digest, "run_dir": str(run_dir), "status": "INSUFFICIENT_DATA", } def test_verify_m8_accepts_complete_or_insufficient_terminal_evidence( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: digest = "e" * 64 run_dir = tmp_path / "run" raw_manifest = tmp_path / "raw.json" config = _mock_m8_config() calls: list[tuple[object, Path, Path, str]] = [] def fake_verify( path: Path, observed_config: object, *, raw_manifest_path: Path, raw_manifest_sha256: str, ) -> SimpleNamespace: calls.append((observed_config, path, raw_manifest_path, raw_manifest_sha256)) return SimpleNamespace( path=run_dir, status="INSUFFICIENT_DATA", raw_manifest_sha256=digest, normalized_manifest_sha256=None, ) monkeypatch.setattr(cli_module, "load_m8_config", lambda path: config) monkeypatch.setattr(cli_module, "verify_m8_result", fake_verify) monkeypatch.setattr(cli_module, "verify_checksums", lambda path: 17) assert ( main( [ "verify-m8", "--config", str(tmp_path / "study.toml"), "--run-dir", str(run_dir), "--raw-manifest", str(raw_manifest), "--raw-manifest-sha256", digest, ] ) == 0 ) assert calls == [(config, run_dir, raw_manifest, digest)] assert json.loads(capsys.readouterr().out)["protected_files"] == 17 def test_report_m8_writes_self_contained_insufficient_report_outside_frozen_bundle( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: digest = "9" * 64 run_dir = tmp_path / "run" output_dir = tmp_path / "external-report" run_dir.mkdir() failure = { "failed_symbol": "ETHUSDT", "failed_date": "2024-01-04", "failed_role": "validation", "failure_stage": "development_normalization", "reason_code": "ARCHIVE_QUALITY_GATE", "reason": "53 temporal.long_silence warnings violated the frozen gate", "replacement_date_selected": False, "reselection_performed": False, "config_sha256": "a" * 64, "config_source_sha256": "b" * 64, "raw_acquisition_manifest_sha256": digest, "bundled_raw_acquisition_manifest_sha256": "c" * 64, "protocol_sha256": "d" * 64, "selection_started": False, "selection_completed_symbols": [], "aggregate_lock_committed": False, "held_out_member_opened": False, "endpoint_evaluation_started": False, "endpoint_evaluation_completed": False, "endpoint_evaluation_completed_symbols": [], "predictions_published": False, "endpoint_artifacts_published": False, "completed_normalizations": [{"symbol": "BTCUSDT", "date": "2024-01-03", "role": "train"}], "stopped_before": [ {"symbol": "BTCUSDT", "date": "2024-01-05", "role": "primary_test"}, {"symbol": "BTCUSDT", "date": "2024-01-06", "role": "replication_test"}, ], } provenance = { "git": { "commit": "e" * 40, "dirty": False, "source_tree_sha256": "f" * 64, } } run_manifest = { "research": {"endpoint_status": "insufficient_data"}, "execution_assumptions": { "status": "NOT_RUN", "fills_calculated": False, "pnl_calculated": False, "capacity_calculated": False, }, } for name, payload in ( ("failure.json", failure), ("provenance.json", provenance), ("run_manifest.json", run_manifest), ): (run_dir / name).write_text(json.dumps(payload), encoding="utf-8") bundled_before = {path.name: path.read_bytes() for path in run_dir.iterdir() if path.is_file()} monkeypatch.setattr(cli_module, "load_m8_config", lambda path: _mock_m8_config()) verification_calls: list[tuple[tuple[object, ...], dict[str, object]]] = [] def fake_verify(*args: object, **kwargs: object) -> object: verification_calls.append((args, kwargs)) return SimpleNamespace( path=run_dir, status="INSUFFICIENT_DATA", raw_manifest_sha256=digest, normalized_manifest_sha256=None, ) monkeypatch.setattr(cli_module, "verify_m8_result", fake_verify) monkeypatch.setattr( cli_module, "write_report_set", lambda *args, **kwargs: pytest.fail("terminal failure report must not be rewritten"), ) assert ( main( [ "report-m8", "--config", str(tmp_path / "study.toml"), "--run-dir", str(run_dir), "--raw-manifest", str(tmp_path / "raw.json"), "--raw-manifest-sha256", digest, "--output-dir", str(output_dir), ] ) == 0 ) payload = json.loads(capsys.readouterr().out) report = output_dir / "insufficient_data.md" assert payload["report"] == str(report) assert payload["reports_regenerated"] is True assert payload["source_bundle_modified"] is False assert payload["report_sha256"] == sha256_file(report) rendered = report.read_text(encoding="utf-8") for expected in ( "2024-01-03` through `2024-01-06", "ETHUSDT", "2024-01-04", "validation", "ARCHIVE_QUALITY_GATE", "53 temporal.long_silence warnings", "Config semantic SHA-256", "Raw acquisition manifest SHA-256", "Git commit", "Git dirty: `false`", "Source-tree SHA-256", "Candidate selection started: `false`", "Held-out member opened: `false`", "Endpoint evaluation started: `false`", "Execution status: `NOT_RUN`", ): assert expected in rendered assert { path.name: path.read_bytes() for path in run_dir.iterdir() if path.is_file() } == bundled_before assert len(verification_calls) == 2 assert verification_calls[0] == verification_calls[1] def test_report_m8_rejects_output_inside_immutable_bundle( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: digest = "8" * 64 run_dir = tmp_path / "run" monkeypatch.setattr(cli_module, "load_m8_config", lambda path: _mock_m8_config()) monkeypatch.setattr( cli_module, "verify_m8_result", lambda *args, **kwargs: SimpleNamespace( path=run_dir, status="INSUFFICIENT_DATA", raw_manifest_sha256=digest, normalized_manifest_sha256=None, ), ) exit_code = main( [ "report-m8", "--config", str(tmp_path / "study.toml"), "--run-dir", str(run_dir), "--raw-manifest", str(tmp_path / "raw.json"), "--raw-manifest-sha256", digest, "--output-dir", str(run_dir / "reports"), ] ) assert exit_code == 2 assert "outside the immutable run bundle" in capsys.readouterr().err @pytest.mark.parametrize( "manifest_args", [ [], ["--raw-manifest", "input.json"], ["--raw-manifest-sha256", "a" * 64], ["--raw-manifest", "input.json", "--raw-manifest-sha256", "A" * 64], ["--raw-manifest", "input.json", "--raw-manifest-sha256", "a" * 63], ["--raw-manifest", "input.json", "--raw-manifest-sha256", "g" * 64], ], ) def test_reproduce_m8_rejects_missing_or_noncanonical_manifest_coordinates( manifest_args: list[str], tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: monkeypatch.setattr( cli_module, "reproduce_m8", lambda *args, **kwargs: pytest.fail("producer must not run after argument failure"), ) with pytest.raises(SystemExit) as caught: main( [ "reproduce-m8", "--config", str(tmp_path / "study.toml"), "--run-dir", str(tmp_path / "run"), *manifest_args, ] ) assert caught.value.code == 2 def test_m8_make_targets_keep_reproduction_explicit_and_checks_offline() -> None: makefile = (PROJECT_ROOT / "Makefile").read_text(encoding="utf-8") reproduce_recipe = makefile.split("reproduce-m8:\n", maxsplit=1)[1].split( "\nverify-run:", maxsplit=1 )[0] assert 'test -n "$(M8_RAW_MANIFEST)"' in reproduce_recipe assert 'test -n "$(M8_RAW_MANIFEST_SHA256)"' in reproduce_recipe assert '--raw-manifest "$(M8_RAW_MANIFEST)"' in reproduce_recipe assert '--raw-manifest-sha256 "$(M8_RAW_MANIFEST_SHA256)"' in reproduce_recipe assert "latest" not in reproduce_recipe.lower() for target, following in (("verify-m8-run", "report:"), ("report-m8", "dashboard:")): recipe = makefile.split(f"{target}:\n", maxsplit=1)[1].split(f"\n{following}", maxsplit=1)[ 0 ] assert 'test -n "$(M8_RAW_MANIFEST)"' in recipe assert 'test -n "$(M8_RAW_MANIFEST_SHA256)"' in recipe assert '--raw-manifest "$(M8_RAW_MANIFEST)"' in recipe assert '--raw-manifest-sha256 "$(M8_RAW_MANIFEST_SHA256)"' in recipe check_dependencies = makefile.split("\ncheck:", maxsplit=1)[1].splitlines()[0] assert "download-m8" not in check_dependencies @pytest.mark.parametrize(("status", "expected_exit"), [("COMPLETE", 0), ("INSUFFICIENT_DATA", 1)]) def test_capture_m8_l2_session_command_uses_frozen_runner_without_source_override( status: str, expected_exit: int, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: config_path = tmp_path / "m8-l2.toml" output_root = tmp_path / "l2" config = object() adapter = object() target = output_root / "sessions" / "authority" bundle = SimpleNamespace( root=target, status=status, session_id="a" * 64, session_date="2026-08-10", role="train", manifest_path=target / "session_manifest.json", manifest_sha256="b" * 64, checksum_path=target / "CHECKSUMS.sha256", marker_path=target / ("_SUCCESS" if status == "COMPLETE" else "INSUFFICIENT_DATA"), reason_codes=() if status == "COMPLETE" else ("GATE_VALID_CONTINUITY_EPOCH_BTCUSDT",), ) calls: list[tuple[object, str, Path, object]] = [] async def fake_capture( loaded: object, session_date: str, root: Path, capture_one: object, **kwargs: object, ) -> object: assert kwargs == {} calls.append((loaded, session_date, root, capture_one)) return bundle monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: config) monkeypatch.setattr(cli_module, "BinanceM8L2Capture", lambda: adapter) monkeypatch.setattr(cli_module, "capture_m8_l2_session", fake_capture) exit_code = main( [ "capture-m8-l2-session", "--config", str(config_path), "--date", "2026-08-10", "--output-root", str(output_root), ] ) assert exit_code == expected_exit assert calls == [(config, "2026-08-10", output_root.resolve(), adapter)] payload = json.loads(capsys.readouterr().out) assert payload["status"] == status assert payload["session_date"] == "2026-08-10" assert payload["session_manifest_sha256"] == "b" * 64 assert payload["live_trading"] is False def test_capture_m8_l2_session_system_failure_uses_error_exit_two( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: object()) async def fail(*args: object, **kwargs: object) -> object: raise OSError("injected capture I/O failure") monkeypatch.setattr(cli_module, "capture_m8_l2_session", fail) exit_code = main( [ "capture-m8-l2-session", "--config", str(tmp_path / "m8-l2.toml"), "--date", "2026-08-10", "--output-root", str(tmp_path / "l2"), ] ) assert exit_code == 2 assert capsys.readouterr().err == "error: injected capture I/O failure\n" @pytest.mark.parametrize("status", ["COMPLETE", "INSUFFICIENT_DATA"]) def test_verify_m8_l2_session_accepts_both_terminal_states( status: str, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: config_path = tmp_path / "m8-l2.toml" bundle_dir = tmp_path / "sessions" / ("a" * 64) config = object() result = SimpleNamespace( root=bundle_dir.absolute(), status=status, session_id="a" * 64, session_date="2026-08-10", role="train", manifest_path=bundle_dir / "session_manifest.json", manifest_sha256="b" * 64, checksum_path=bundle_dir / "CHECKSUMS.sha256", marker_path=bundle_dir / ("_SUCCESS" if status == "COMPLETE" else "INSUFFICIENT_DATA"), reason_codes=() if status == "COMPLETE" else ("GATE_CROSS_SYMBOL_OVERLAP",), ) calls: list[tuple[Path, object]] = [] def fake_verify(path: Path, *, expected_config: object) -> object: calls.append((path, expected_config)) return result monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: config) monkeypatch.setattr(cli_module, "verify_m8_l2_session_bundle", fake_verify) exit_code = main( [ "verify-m8-l2-session", "--config", str(config_path), "--bundle-dir", str(bundle_dir), ] ) assert exit_code == 0 assert calls == [(bundle_dir, config)] payload = json.loads(capsys.readouterr().out) assert payload["status"] == status assert payload["integrity"] == "verified" assert payload["session_id"] == "a" * 64 assert payload["reason_codes"] == list(result.reason_codes) assert payload["live_trading"] is False @pytest.mark.parametrize( "message", [ "checksum mismatch for symbols/BTCUSDT/capture_summary.json", "caller config semantics differ from the session authority", ], ) def test_verify_m8_l2_session_rejects_tampering_and_wrong_config( message: str, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: config = object() bundle_dir = tmp_path / "sessions" / ("a" * 64) monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: config) def fail(path: Path, *, expected_config: object) -> object: assert path == bundle_dir assert expected_config is config raise M8L2VerificationError(message) monkeypatch.setattr(cli_module, "verify_m8_l2_session_bundle", fail) exit_code = main( [ "verify-m8-l2-session", "--config", str(tmp_path / "m8-l2.toml"), "--bundle-dir", str(bundle_dir), ] ) assert exit_code == 2 captured = capsys.readouterr() assert captured.out == "" assert captured.err == f"error: {message}\n" def test_m8_l2_make_target_is_explicit_and_check_remains_offline() -> None: makefile = (PROJECT_ROOT / "Makefile").read_text(encoding="utf-8") assert "M8_L2_CONFIG ?= configs/m8_l2_capture_study.toml" in makefile assert "M8_L2_DATA_ROOT ?= data/m8_l2" in makefile assert "M8_L2_SESSION_DATE ?=" in makefile assert "M8_L2_BUNDLE_DIR ?=" in makefile capture_recipe = makefile.split("capture-m8-l2-session:\n", maxsplit=1)[1].split( "\nverify-m8-l2-session:", maxsplit=1 )[0] assert 'test -n "$(M8_L2_SESSION_DATE)"' in capture_recipe assert '--config "$(M8_L2_CONFIG)"' in capture_recipe assert '--date "$(M8_L2_SESSION_DATE)"' in capture_recipe assert '--output-root "$(M8_L2_DATA_ROOT)"' in capture_recipe verify_recipe = makefile.split("verify-m8-l2-session:\n", maxsplit=1)[1].split( "\nvalidate-data:", maxsplit=1 )[0] assert 'test -n "$(M8_L2_BUNDLE_DIR)"' in verify_recipe assert '--config "$(M8_L2_CONFIG)"' in verify_recipe assert '--bundle-dir "$(M8_L2_BUNDLE_DIR)"' in verify_recipe check_dependencies = makefile.split("\ncheck:", maxsplit=1)[1].splitlines()[0] assert "capture-m8-l2-session" not in check_dependencies assert "verify-m8-l2-session" not in check_dependencies def test_m8_l2_make_contract_normalizes_only_valid_terminal_exit_one( tmp_path: Path, ) -> None: fake_python = tmp_path / "fake-python" fake_python.write_text( '#!/bin/sh\nprintf \'{"status":"INSUFFICIENT_DATA"}\\n\'\nexit "$FAKE_EXIT"\n', encoding="ascii", ) fake_python.chmod(0o755) base_environment = {**os.environ, "FAKE_EXIT": "1"} command = [ "make", "--no-print-directory", "capture-m8-l2-session", f"PYTHON={fake_python}", "M8_L2_SESSION_DATE=2026-08-10", ] valid_terminal = subprocess.run( command, cwd=PROJECT_ROOT, env=base_environment, check=False, capture_output=True, text=True, ) assert valid_terminal.returncode == 0 assert json.loads(valid_terminal.stdout)["status"] == "INSUFFICIENT_DATA" system_failure = subprocess.run( command, cwd=PROJECT_ROOT, env={**base_environment, "FAKE_EXIT": "2"}, check=False, capture_output=True, text=True, ) assert system_failure.returncode != 0 makefile = (PROJECT_ROOT / "Makefile").read_text(encoding="utf-8") for command_name in ( "capture-m8-l2-session", "lock-m8-l2-development", "verify-m8-l2-development-lock", "reproduce-m8-l2", "verify-m8-l2-run", "report-m8-l2", ): recipe_line = next( line for line in makefile.splitlines() if f"microstructure.cli {command_name} " in line ) assert "|| status=$$?" in recipe_line assert 'if [ "$$status" -eq 1 ]; then exit 0; fi' in recipe_line assert 'exit "$$status"' in recipe_line def _m8_l2_development_cli_fixture( tmp_path: Path, *, train_status: str = "COMPLETE", validation_status: str = "COMPLETE", ) -> tuple[list[str], SimpleNamespace, SimpleNamespace]: train_root = tmp_path / "train" validation_root = tmp_path / "validation" train_root.mkdir() validation_root.mkdir() train_checksums = train_root / "CHECKSUMS.sha256" validation_checksums = validation_root / "CHECKSUMS.sha256" train_checksums.write_bytes(b"train checksums authority\n") validation_checksums.write_bytes(b"validation checksums authority\n") train = SimpleNamespace( root=train_root.absolute(), status=train_status, session_id="1" * 64, session_date="2026-08-10", role="train", manifest_path=train_root / "session_manifest.json", manifest_sha256="a" * 64, checksum_path=train_checksums, marker_path=train_root / ("_SUCCESS" if train_status == "COMPLETE" else "INSUFFICIENT_DATA"), reason_codes=() if train_status == "COMPLETE" else ("GATE_TRAIN",), ) validation = SimpleNamespace( root=validation_root.absolute(), status=validation_status, session_id="2" * 64, session_date="2026-08-11", role="validation", manifest_path=validation_root / "session_manifest.json", manifest_sha256="b" * 64, checksum_path=validation_checksums, marker_path=( validation_root / ("_SUCCESS" if validation_status == "COMPLETE" else "INSUFFICIENT_DATA") ), reason_codes=() if validation_status == "COMPLETE" else ("GATE_VALIDATION",), ) arguments = [ "--capture-config", str(tmp_path / "capture.toml"), "--analysis-config", str(tmp_path / "analysis.toml"), "--train-bundle-dir", str(train_root), "--train-manifest-sha256", train.manifest_sha256, "--train-checksums-sha256", sha256_file(train_checksums), "--validation-bundle-dir", str(validation_root), "--validation-manifest-sha256", validation.manifest_sha256, "--validation-checksums-sha256", sha256_file(validation_checksums), "--lock-dir", str(tmp_path / "development-lock"), ] return arguments, train, validation def test_lock_m8_l2_development_uses_only_explicit_session_authorities( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: arguments, train, validation = _m8_l2_development_cli_fixture(tmp_path) capture_config = object() analysis_config = object() strict_input = object() calls: list[tuple[object, ...]] = [] monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: capture_config) monkeypatch.setattr(cli_module, "load_m8_l2_analysis_config", lambda path: analysis_config) def fake_verify(path: Path, *, expected_config: object) -> object: assert expected_config is capture_config return train if path == train.root else validation def fake_strict_input( path: Path, *, expected_config: object, expected_date: str, expected_role: str, expected_file_authority: object, expected_campaign: object | None, ) -> object: calls.append( ( path, expected_config, expected_date, expected_role, expected_file_authority, expected_campaign, ) ) return strict_input def fake_lock( capture: object, analysis: object, train_path: Path, validation_path: Path, lock_path: Path, *, input_loader: object, expected_session_file_authorities: object, ) -> object: assert capture is capture_config assert analysis is analysis_config assert (train_path, validation_path) == (train.root, validation.root) assert callable(input_loader) assert expected_session_file_authorities == { "2026-08-10": cli_module.L2SessionFileAuthority( train.manifest_sha256, hashlib.sha256(train.checksum_path.read_bytes()).hexdigest(), ), "2026-08-11": cli_module.L2SessionFileAuthority( validation.manifest_sha256, hashlib.sha256(validation.checksum_path.read_bytes()).hexdigest(), ), } assert ( input_loader( train_path, expected_config=capture_config, expected_date="2026-08-10", expected_role="train", ) is strict_input ) return SimpleNamespace( root=lock_path, aggregate_path=lock_path / "development_lock.json", aggregate_sha256="d" * 64, marker_path=lock_path / "_LOCKED", created_at_utc="2026-08-11T15:00:00Z", children=( SimpleNamespace( symbol="BTCUSDT", endpoint="event_20", path=lock_path / "BTCUSDT" / "event_20" / "lock.json", sha256="e" * 64, selection_lock_sha256="f" * 64, fitted_state_sha256="0" * 64, ), ), ) monkeypatch.setattr(cli_module, "verify_m8_l2_session_bundle", fake_verify) monkeypatch.setattr(cli_module, "verify_m8_l2_development_input", fake_strict_input) monkeypatch.setattr(cli_module, "lock_m8_l2_development", fake_lock) assert main(["lock-m8-l2-development", *arguments]) == 0 payload = json.loads(capsys.readouterr().out) assert payload["status"] == "LOCKED" assert payload["development_lock_sha256"] == "d" * 64 assert payload["heldout_accessed"] is False assert payload["live_trading"] is False assert calls[0][4].manifest_sha256 == "a" * 64 assert calls[0][4].checksums_sha256 == sha256_file(train.checksum_path) def test_lock_m8_l2_development_returns_one_for_verified_insufficient_session( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: arguments, train, validation = _m8_l2_development_cli_fixture( tmp_path, validation_status="INSUFFICIENT_DATA", ) monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: object()) monkeypatch.setattr(cli_module, "load_m8_l2_analysis_config", lambda path: object()) monkeypatch.setattr( cli_module, "verify_m8_l2_session_bundle", lambda path, **kwargs: train if path == train.root else validation, ) lock_dir = Path(arguments[arguments.index("--lock-dir") + 1]).absolute() monkeypatch.setattr( cli_module, "lock_m8_l2_development", lambda *args, **kwargs: SimpleNamespace( root=lock_dir, aggregate_path=lock_dir / "development_lock.json", aggregate_sha256="d" * 64, marker_path=lock_dir / "_NOT_CREATED", created_at_utc="2026-08-11T15:00:00Z", children=(), status="NOT_CREATED", reason_codes=("DEVELOPMENT_SESSION_INSUFFICIENT::validation::GATE_VALIDATION",), ), ) assert main(["lock-m8-l2-development", *arguments]) == 1 payload = json.loads(capsys.readouterr().out) assert payload["status"] == "NOT_CREATED" assert payload["development_lock_sha256"] == "d" * 64 assert payload["reason_codes"] == [ "DEVELOPMENT_SESSION_INSUFFICIENT::validation::GATE_VALIDATION" ] assert payload["heldout_accessed"] is False def test_verify_m8_l2_development_lock_binds_expected_aggregate_sha( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: arguments, train, validation = _m8_l2_development_cli_fixture(tmp_path) capture_config = object() analysis_config = object() expected_lock_sha = "c" * 64 lock_dir = (tmp_path / "development-lock").absolute() monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: capture_config) monkeypatch.setattr(cli_module, "load_m8_l2_analysis_config", lambda path: analysis_config) monkeypatch.setattr( cli_module, "verify_m8_l2_session_bundle", lambda path, **kwargs: train if path == train.root else validation, ) def fake_verify_lock(*args: object, **kwargs: object) -> object: assert args == (capture_config, analysis_config, train.root, validation.root, lock_dir) assert kwargs == {"expected_lock_sha256": expected_lock_sha} return SimpleNamespace( root=lock_dir, aggregate_path=lock_dir / "development_lock.json", aggregate_sha256=expected_lock_sha, marker_path=lock_dir / "_LOCKED", created_at_utc="2026-08-11T15:00:00Z", children=(), ) monkeypatch.setattr(cli_module, "verify_m8_l2_development_lock", fake_verify_lock) assert ( main( [ "verify-m8-l2-development-lock", *arguments, "--development-lock-sha256", expected_lock_sha, ] ) == 0 ) payload = json.loads(capsys.readouterr().out) assert payload["integrity"] == "verified" assert payload["development_lock_sha256"] == expected_lock_sha def test_verify_m8_l2_not_created_authority_returns_one_with_verified_integrity( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: arguments, train, validation = _m8_l2_development_cli_fixture( tmp_path, validation_status="INSUFFICIENT_DATA", ) expected_sha = "c" * 64 lock_dir = Path(arguments[arguments.index("--lock-dir") + 1]).absolute() monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: object()) monkeypatch.setattr(cli_module, "load_m8_l2_analysis_config", lambda path: object()) monkeypatch.setattr( cli_module, "verify_m8_l2_session_bundle", lambda path, **kwargs: train if path == train.root else validation, ) monkeypatch.setattr( cli_module, "verify_m8_l2_development_lock", lambda *args, **kwargs: SimpleNamespace( root=lock_dir, aggregate_path=lock_dir / "development_lock.json", aggregate_sha256=expected_sha, marker_path=lock_dir / "_NOT_CREATED", created_at_utc="2026-08-11T15:00:00Z", children=(), status="NOT_CREATED", reason_codes=("DEVELOPMENT_SESSION_INSUFFICIENT::validation::GATE_VALIDATION",), ), ) assert ( main( [ "verify-m8-l2-development-lock", *arguments, "--development-lock-sha256", expected_sha, ] ) == 1 ) payload = json.loads(capsys.readouterr().out) assert payload["status"] == "NOT_CREATED" assert payload["integrity"] == "verified" assert payload["terminal_marker"].endswith("/_NOT_CREATED") def test_m8_l2_development_cli_rejects_noncanonical_authority_sha( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: arguments, _, _ = _m8_l2_development_cli_fixture(tmp_path) digest_index = arguments.index("--train-manifest-sha256") + 1 arguments[digest_index] = "A" * 64 monkeypatch.setattr( cli_module, "lock_m8_l2_development", lambda *args, **kwargs: pytest.fail("argument failure must precede lock production"), ) with pytest.raises(SystemExit) as caught: main(["lock-m8-l2-development", *arguments]) assert caught.value.code == 2 def test_m8_l2_development_make_targets_are_explicit_and_not_in_check() -> None: makefile = (PROJECT_ROOT / "Makefile").read_text(encoding="utf-8") gitignore_lines = (PROJECT_ROOT / ".gitignore").read_text(encoding="utf-8").splitlines() assert "data/m8_l2/**" in gitignore_lines lock_recipe = makefile.split("lock-m8-l2-development:\n", maxsplit=1)[1].split( "\nverify-m8-l2-development-lock:", maxsplit=1 )[0] verify_recipe = makefile.split("verify-m8-l2-development-lock:\n", maxsplit=1)[1].split( "\nvalidate-data:", maxsplit=1 )[0] for variable in ( "M8_L2_TRAIN_BUNDLE_DIR", "M8_L2_TRAIN_MANIFEST_SHA256", "M8_L2_TRAIN_CHECKSUMS_SHA256", "M8_L2_VALIDATION_BUNDLE_DIR", "M8_L2_VALIDATION_MANIFEST_SHA256", "M8_L2_VALIDATION_CHECKSUMS_SHA256", "M8_L2_DEVELOPMENT_LOCK_DIR", ): assert f'test -n "$({variable})"' in lock_recipe assert f'"$({variable})"' in lock_recipe assert f'test -n "$({variable})"' in verify_recipe assert f'"$({variable})"' in verify_recipe assert 'test -n "$(M8_L2_DEVELOPMENT_LOCK_SHA256)"' in verify_recipe assert '--development-lock-sha256 "$(M8_L2_DEVELOPMENT_LOCK_SHA256)"' in verify_recipe for recipe in (lock_recipe, verify_recipe): assert "latest" not in recipe.lower() check_dependencies = makefile.split("\ncheck:", maxsplit=1)[1].splitlines()[0] assert "lock-m8-l2-development" not in check_dependencies assert "verify-m8-l2-development-lock" not in check_dependencies def test_m8_l2_final_make_targets_bind_four_sessions_and_stay_offline() -> None: makefile = (PROJECT_ROOT / "Makefile").read_text(encoding="utf-8") assert "M8_L2_RUN_DIR ?= artifacts/runs/binance-m8-live-l2" in makefile assert "M8_L2_REPORT_DIR ?= artifacts/runs/binance-m8-live-l2-reports" in makefile reproduce_recipe = makefile.split("reproduce-m8-l2:\n", maxsplit=1)[1].split( "\nverify-m8-l2-run:", maxsplit=1 )[0] verify_recipe = makefile.split("verify-m8-l2-run:\n", maxsplit=1)[1].split( "\nreport-m8-l2:", maxsplit=1 )[0] report_recipe = makefile.split("report-m8-l2:\n", maxsplit=1)[1].split( "\nvalidate-data:", maxsplit=1 )[0] authority_variables = ( "M8_L2_TRAIN_BUNDLE_DIR", "M8_L2_TRAIN_MANIFEST_SHA256", "M8_L2_TRAIN_CHECKSUMS_SHA256", "M8_L2_VALIDATION_BUNDLE_DIR", "M8_L2_VALIDATION_MANIFEST_SHA256", "M8_L2_VALIDATION_CHECKSUMS_SHA256", "M8_L2_DEVELOPMENT_LOCK_DIR", "M8_L2_DEVELOPMENT_LOCK_SHA256", "M8_L2_PRIMARY_BUNDLE_DIR", "M8_L2_PRIMARY_MANIFEST_SHA256", "M8_L2_PRIMARY_CHECKSUMS_SHA256", "M8_L2_REPLICATION_BUNDLE_DIR", "M8_L2_REPLICATION_MANIFEST_SHA256", "M8_L2_REPLICATION_CHECKSUMS_SHA256", ) for recipe in (reproduce_recipe, verify_recipe, report_recipe): for variable in authority_variables: assert f'test -n "$({variable})"' in recipe assert f'"$({variable})"' in recipe for role in ("train", "validation", "primary", "replication"): assert f"--{role}-bundle-dir" in recipe assert f"--{role}-manifest-sha256" in recipe assert f"--{role}-checksums-sha256" in recipe assert "--development-lock-dir" in recipe assert "--development-lock-sha256" in recipe assert ' --run-dir "$(M8_L2_RUN_DIR)"' in recipe assert "latest" not in recipe.lower() for recipe in (verify_recipe, report_recipe): assert 'test -n "$(M8_L2_RUN_MANIFEST_SHA256)"' in recipe assert 'test -n "$(M8_L2_RUN_CHECKSUMS_SHA256)"' in recipe assert '--run-manifest-sha256 "$(M8_L2_RUN_MANIFEST_SHA256)"' in recipe assert '--run-checksums-sha256 "$(M8_L2_RUN_CHECKSUMS_SHA256)"' in recipe assert '--output-dir "$(M8_L2_REPORT_DIR)"' in report_recipe check_dependencies = makefile.split("\ncheck:", maxsplit=1)[1].splitlines()[0] for target in ("reproduce-m8-l2", "verify-m8-l2-run", "report-m8-l2"): assert target not in check_dependencies def _m8_l2_study_cli_arguments( tmp_path: Path, *, include_run_authority: bool, ) -> list[str]: arguments = [ "--capture-config", str(tmp_path / "capture.toml"), "--analysis-config", str(tmp_path / "analysis.toml"), ] for index, role in enumerate(("train", "validation", "primary", "replication"), start=1): arguments.extend( [ f"--{role}-bundle-dir", str(tmp_path / role), f"--{role}-manifest-sha256", format(index, "x") * 64, f"--{role}-checksums-sha256", format(index + 4, "x") * 64, ] ) arguments.extend( [ "--development-lock-dir", str(tmp_path / "development-lock"), "--development-lock-sha256", "9" * 64, "--run-dir", str(tmp_path / "run"), ] ) if include_run_authority: arguments.extend( [ "--run-manifest-sha256", "a" * 64, "--run-checksums-sha256", "b" * 64, ] ) return arguments def _fake_m8_l2_study_result(tmp_path: Path, status: str) -> SimpleNamespace: root = (tmp_path / "run").absolute() return SimpleNamespace( root=root, status=status, manifest_path=root / "run_manifest.json", manifest_sha256="a" * 64, checksum_path=root / "CHECKSUMS.sha256", checksum_sha256="b" * 64, marker_path=root / ("_SUCCESS" if status == "COMPLETE" else "INSUFFICIENT_DATA"), reason_codes=() if status == "COMPLETE" else ("PRIMARY_SESSION_NOT_COMPLETE",), ) @pytest.mark.parametrize(("status", "expected_exit"), [("COMPLETE", 0), ("INSUFFICIENT_DATA", 1)]) def test_reproduce_m8_l2_binds_all_four_explicit_session_authorities( status: str, expected_exit: int, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: capture_config = object() analysis_config = object() result = _fake_m8_l2_study_result(tmp_path, status) calls: list[tuple[object, ...]] = [] monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: capture_config) monkeypatch.setattr(cli_module, "load_m8_l2_analysis_config", lambda path: analysis_config) def fake_reproduce(*args: object) -> object: calls.append(args) return result monkeypatch.setattr(cli_module, "reproduce_m8_l2_study", fake_reproduce) assert ( main( [ "reproduce-m8-l2", *_m8_l2_study_cli_arguments(tmp_path, include_run_authority=False), ] ) == expected_exit ) assert len(calls) == 1 call = calls[0] assert call[0:2] == (capture_config, analysis_config) for index, (position, role) in enumerate( zip((2, 3, 6, 7), ("train", "validation", "primary", "replication"), strict=True), start=1, ): authority = call[position] assert isinstance(authority, cli_module.L2StudySessionAuthority) assert authority.bundle_path == (tmp_path / role).absolute() assert authority.manifest_sha256 == format(index, "x") * 64 assert authority.checksums_sha256 == format(index + 4, "x") * 64 assert call[4] == (tmp_path / "development-lock").absolute() assert call[5] == "9" * 64 assert call[8] == (tmp_path / "run").absolute() payload = json.loads(capsys.readouterr().out) assert payload["status"] == status assert payload["run_manifest_sha256"] == "a" * 64 assert payload["checksums_sha256"] == "b" * 64 assert payload["reason_codes"] == list(result.reason_codes) assert payload["live_trading"] is False @pytest.mark.parametrize(("status", "expected_exit"), [("COMPLETE", 0), ("INSUFFICIENT_DATA", 1)]) def test_verify_m8_l2_run_requires_and_forwards_terminal_run_authority( status: str, expected_exit: int, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: capture_config = object() analysis_config = object() result = _fake_m8_l2_study_result(tmp_path, status) calls: list[tuple[tuple[object, ...], dict[str, object]]] = [] monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: capture_config) monkeypatch.setattr(cli_module, "load_m8_l2_analysis_config", lambda path: analysis_config) def fake_verify(*args: object, **kwargs: object) -> object: calls.append((args, kwargs)) return result monkeypatch.setattr(cli_module, "verify_m8_l2_study_run", fake_verify) assert ( main( [ "verify-m8-l2-run", *_m8_l2_study_cli_arguments(tmp_path, include_run_authority=True), ] ) == expected_exit ) assert calls[0][1] == { "expected_manifest_sha256": "a" * 64, "expected_checksums_sha256": "b" * 64, } payload = json.loads(capsys.readouterr().out) assert payload["integrity"] == "verified" assert payload["status"] == status @pytest.mark.parametrize(("status", "expected_exit"), [("COMPLETE", 0), ("INSUFFICIENT_DATA", 1)]) def test_report_m8_l2_reverifies_then_writes_only_to_external_output( status: str, expected_exit: int, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], ) -> None: capture_config = object() analysis_config = object() result = _fake_m8_l2_study_result(tmp_path, status) report_data = object() output = (tmp_path / "reports").absolute() calls: list[tuple[str, tuple[object, ...], dict[str, object]]] = [] monkeypatch.setattr(cli_module, "load_m8_l2_config", lambda path: capture_config) monkeypatch.setattr(cli_module, "load_m8_l2_analysis_config", lambda path: analysis_config) def fake_verify(*args: object, **kwargs: object) -> object: calls.append(("verify", args, kwargs)) return result def fake_load(*args: object, **kwargs: object) -> object: calls.append(("load", args, kwargs)) return report_data def fake_write(path: Path, data: object) -> tuple[Path, Path, Path]: assert path == output assert data is report_data return ( path / "technical_report.md", path / "executive_memo.md", path / "model_comparison.md", ) monkeypatch.setattr(cli_module, "verify_m8_l2_study_run", fake_verify) monkeypatch.setattr(cli_module, "load_m8_l2_report_data", fake_load) monkeypatch.setattr(cli_module, "write_l2_report_set", fake_write) monkeypatch.setattr(cli_module, "canonical_report_data_sha256", lambda data: "c" * 64) assert ( main( [ "report-m8-l2", *_m8_l2_study_cli_arguments(tmp_path, include_run_authority=True), "--output-dir", str(output), ] ) == expected_exit ) assert [call[0] for call in calls] == ["verify", "load"] assert calls[0][1:] == calls[1][1:] payload = json.loads(capsys.readouterr().out) assert payload["output_dir"] == str(output) assert payload["technical_report"] == str(output / "technical_report.md") assert payload["executive_memo"] == str(output / "executive_memo.md") assert payload["model_comparison"] == str(output / "model_comparison.md") assert payload["report_inputs_sha256"] == "c" * 64 assert payload["source_bundle_modified"] is False @pytest.mark.parametrize( ("command", "include_run_authority"), [ ("reproduce-m8-l2", False), ("verify-m8-l2-run", True), ("report-m8-l2", True), ], ) def test_m8_l2_final_commands_reject_noncanonical_session_authority_before_io( command: str, include_run_authority: bool, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: arguments = _m8_l2_study_cli_arguments( tmp_path, include_run_authority=include_run_authority, ) arguments[arguments.index("--primary-manifest-sha256") + 1] = "A" * 64 if command == "report-m8-l2": arguments.extend(["--output-dir", str(tmp_path / "reports")]) monkeypatch.setattr( cli_module, "load_m8_l2_config", lambda path: pytest.fail("argument rejection must precede config I/O"), ) with pytest.raises(SystemExit) as caught: main([command, *arguments]) assert caught.value.code == 2 def test_live_depth_capture_resnapshots_and_preserves_every_reconnect_epoch( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: captured = [ _captured_depth( sequence=11, continuity_id="epoch-1", event_ts_ns=2_000_000_000, ), _captured_depth( sequence=21, continuity_id="epoch-2", event_ts_ns=3_000_000_000, ), ] snapshot_calls: list[str] = [] class FakeClient: def fetch_exchange_info(self, *, symbol: str, raw_root: Path) -> SimpleNamespace: assert symbol == "BTCUSDT" assert raw_root == tmp_path / "raw" return SimpleNamespace(tick_size=Decimal("0.01"), lot_size=Decimal("0.001")) def fetch_depth_snapshot( self, *, symbol: str, raw_root: Path, continuity_id: str, tick_size: Decimal, lot_size: Decimal, ) -> BookSnapshot: snapshot_calls.append(continuity_id) last_update_id = 10 if continuity_id == "epoch-1" else 20 received_ts_ns = 1_900_000_000 if continuity_id == "epoch-1" else 2_900_000_000 return _preserved_snapshot( output_root=tmp_path, continuity_id=continuity_id, last_update_id=last_update_id, received_ts_ns=received_ts_ns, ) class FakeCollector: url = "wss://example.invalid/stream" def __init__(self, **kwargs: object) -> None: assert kwargs["symbols"] == ("BTCUSDT",) async def stream(self, *, max_messages: int | None = None) -> AsyncIterator[CapturedDepth]: assert max_messages == 2 for item in captured: yield item monkeypatch.setattr(cli_module, "BinancePublicClient", FakeClient) monkeypatch.setattr(cli_module, "BinanceLiveDepthCollector", FakeCollector) result = asyncio.run( cli_module._capture_depth( symbol="BTCUSDT", max_messages=2, output_root=tmp_path, ) ) assert result.messages == 2 assert snapshot_calls == ["epoch-1", "epoch-2"] assert result.reconstruction_status == "LIVE" assert result.book_observations == 2 assert result.quality_errors == 0 summary = read_json(result.summary_path) assert summary["capture_status"] == "COMPLETE" assert summary["continuity_epochs"] == 2 assert [item["continuity_id"] for item in summary["continuity_epoch_coverage"]] == [ "epoch-1", "epoch-2", ] assert sum(item["messages"] for item in summary["continuity_epoch_coverage"]) == 2 assert summary["normalized_messages"] == 2 assert summary["excluded_messages"] == 0 assert all( entry["rows"] == expected for entry, expected in ( (summary["normalized_dataset_manifests"]["book_snapshots"], 2), (summary["normalized_dataset_manifests"]["depth_deltas"], 2), (summary["normalized_dataset_manifests"]["book_observations"], 2), (summary["normalized_dataset_manifests"]["sequence_gaps"], 0), ) ) with result.raw_path.open(encoding="utf-8") as handle: journal = [json.loads(line) for line in handle] assert [event["event_kind"] for event in journal] == [ "websocket_frame", "rest_snapshot_anchor", "websocket_frame", "rest_snapshot_anchor", ] assert base64.b64decode(journal[0]["payload_base64"]).decode() == captured[0].raw_payload second_result = asyncio.run( cli_module._capture_depth( symbol="BTCUSDT", max_messages=2, output_root=tmp_path, ) ) latest_pointer = read_json(tmp_path / "quality" / "live_depth_capture.summary.json") assert result.summary_path.is_file() assert second_result.summary_path.is_file() assert second_result.summary_path != result.summary_path assert latest_pointer["capture_status"] == "LATEST_POINTER" assert latest_pointer["authoritative_summary_path"] == str(second_result.summary_path) def test_live_depth_duration_completes_gracefully_before_message_ceiling( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: item = _captured_depth( sequence=1, continuity_id="epoch-duration", event_ts_ns=2_000_000_000, ) class FakeClient: def fetch_exchange_info(self, *, symbol: str, raw_root: Path) -> SimpleNamespace: return SimpleNamespace(tick_size=Decimal("0.01"), lot_size=Decimal("0.001")) def fetch_depth_snapshot(self, **kwargs: object) -> BookSnapshot: return _preserved_snapshot( output_root=tmp_path, continuity_id=str(kwargs["continuity_id"]), last_update_id=0, received_ts_ns=1_900_000_000, ) class FakeCollector: url = "wss://example.invalid/stream" def __init__(self, **kwargs: object) -> None: self.callback = kwargs["on_raw_frame"] async def stream(self, *, max_messages: int | None = None) -> AsyncIterator[CapturedDepth]: assert max_messages == 10 received_ts_ns = item.delta.received_ts_ns assert received_ts_ns is not None self.callback( RawDepthFrame( payload=item.raw_payload.encode(), was_text=True, received_ts_ns=received_ts_ns, capture_seq=1, continuity_id="epoch-duration", ) ) yield item await asyncio.sleep(60) monkeypatch.setattr(cli_module, "BinancePublicClient", FakeClient) monkeypatch.setattr(cli_module, "BinanceLiveDepthCollector", FakeCollector) result = asyncio.run( cli_module._capture_depth( symbol="BTCUSDT", max_messages=10, duration_seconds=0.01, output_root=tmp_path, ) ) assert result.messages == 1 assert result.completion_reason == "duration_elapsed" assert result.requested_duration_seconds == 0.01 assert result.elapsed_monotonic_seconds >= 0.009 summary = read_json(result.summary_path) assert summary["completion_reason"] == "duration_elapsed" assert summary["message_safety_ceiling"] == 10 assert summary["requested_duration_seconds"] == 0.01 assert summary["max_continuity_epoch_seconds"] == 0.0 def test_live_depth_duration_fails_if_message_safety_ceiling_arrives_first( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: class FakeClient: def fetch_exchange_info(self, *, symbol: str, raw_root: Path) -> SimpleNamespace: return SimpleNamespace(tick_size=Decimal("0.01"), lot_size=Decimal("0.001")) def fetch_depth_snapshot(self, **kwargs: object) -> BookSnapshot: return _preserved_snapshot( output_root=tmp_path, continuity_id=str(kwargs["continuity_id"]), last_update_id=0, received_ts_ns=1_900_000_000, ) class FakeCollector: url = "wss://example.invalid/stream" def __init__(self, **kwargs: object) -> None: self.callback = kwargs["on_raw_frame"] async def stream(self, *, max_messages: int | None = None) -> AsyncIterator[CapturedDepth]: assert max_messages == 2 for sequence in (1, 2): item = _captured_depth( sequence=sequence, continuity_id="epoch-cap", event_ts_ns=2_000_000_000 + sequence, ) received_ts_ns = item.delta.received_ts_ns assert received_ts_ns is not None self.callback( RawDepthFrame( payload=item.raw_payload.encode(), was_text=True, received_ts_ns=received_ts_ns, capture_seq=sequence, continuity_id="epoch-cap", ) ) yield item monkeypatch.setattr(cli_module, "BinancePublicClient", FakeClient) monkeypatch.setattr(cli_module, "BinanceLiveDepthCollector", FakeCollector) with pytest.raises(RuntimeError, match="message safety ceiling"): asyncio.run( cli_module._capture_depth( symbol="BTCUSDT", max_messages=2, duration_seconds=60.0, output_root=tmp_path, ) ) assert not list((tmp_path / "quality").glob("live_depth_capture.*.summary.json")) assert list((tmp_path / "quality").glob("live_depth_capture.*.failed.json")) def test_live_depth_capture_is_one_pass_and_history_independent_in_memory( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: message_count = 2_050 yielded = 0 stream_calls = 0 snapshot_calls = 0 class FakeClient: def fetch_exchange_info(self, *, symbol: str, raw_root: Path) -> SimpleNamespace: return SimpleNamespace(tick_size=Decimal("0.01"), lot_size=Decimal("0.001")) def fetch_depth_snapshot(self, **kwargs: object) -> BookSnapshot: nonlocal snapshot_calls snapshot_calls += 1 return _preserved_snapshot( output_root=tmp_path, continuity_id=str(kwargs["continuity_id"]), last_update_id=0, received_ts_ns=1_000_000_000, ) class FakeCollector: url = "wss://example.invalid/stream" def __init__(self, **kwargs: object) -> None: callback = kwargs["on_raw_frame"] assert callable(callback) self.callback = callback async def stream(self, *, max_messages: int | None = None) -> AsyncIterator[CapturedDepth]: nonlocal stream_calls, yielded stream_calls += 1 assert max_messages == message_count for sequence in range(1, message_count + 1): item = _captured_depth( sequence=sequence, continuity_id="epoch-1", event_ts_ns=2_000_000_000 + sequence, ) received_ts_ns = item.delta.received_ts_ns assert received_ts_ns is not None self.callback( RawDepthFrame( payload=item.raw_payload.encode(), was_text=True, received_ts_ns=received_ts_ns, capture_seq=sequence, continuity_id="epoch-1", ) ) yielded += 1 yield item monkeypatch.setattr(cli_module, "BinancePublicClient", FakeClient) monkeypatch.setattr(cli_module, "BinanceLiveDepthCollector", FakeCollector) result = asyncio.run( cli_module._capture_depth( symbol="BTCUSDT", max_messages=message_count, output_root=tmp_path, ) ) assert stream_calls == 1 assert yielded == message_count assert snapshot_calls == 1 assert result.messages == message_count assert result.book_observations == message_count summary = read_json(result.summary_path) assert max(summary["max_buffered_rows_per_dataset"].values()) <= 1_024 assert max(summary["max_buffered_estimated_bytes_per_dataset"].values()) <= 16 * 1024 * 1024 depth_manifest_entry = summary["normalized_dataset_manifests"]["depth_deltas"] depth_manifest = read_json(depth_manifest_entry["manifest_path"]) assert depth_manifest["rows"] == message_count assert len(depth_manifest["artifacts"]) == 1 with result.raw_path.open(encoding="utf-8") as handle: assert sum(1 for _ in handle) == message_count + 1 def test_live_depth_failure_atomically_preserves_preparse_frame_without_completion( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: malformed = b"\xffnot-json\n" class FakeClient: def fetch_exchange_info(self, *, symbol: str, raw_root: Path) -> SimpleNamespace: return SimpleNamespace(tick_size=Decimal("0.01"), lot_size=Decimal("0.001")) class FakeCollector: url = "wss://example.invalid/stream" def __init__(self, **kwargs: object) -> None: self.callback = kwargs["on_raw_frame"] async def stream(self, *, max_messages: int | None = None) -> AsyncIterator[CapturedDepth]: self.callback( RawDepthFrame( payload=malformed, was_text=False, received_ts_ns=2_000_000_100, capture_seq=0, continuity_id="epoch-parse-failure", ) ) raise UnicodeDecodeError("utf-8", malformed, 0, 1, "invalid start byte") if False: # pragma: no cover - makes this an async generator yield _captured_depth( sequence=1, continuity_id="unreachable", event_ts_ns=1, ) monkeypatch.setattr(cli_module, "BinancePublicClient", FakeClient) monkeypatch.setattr(cli_module, "BinanceLiveDepthCollector", FakeCollector) with pytest.raises(UnicodeDecodeError): asyncio.run( cli_module._capture_depth( symbol="BTCUSDT", max_messages=1, output_root=tmp_path, ) ) assert not (tmp_path / "quality" / "live_depth_capture.summary.json").exists() [failed_raw] = list( (tmp_path / "raw" / "binance_spot" / "depth_stream" / "BTCUSDT").glob( "capture-failed-*.ndjson" ) ) [event] = [json.loads(line) for line in failed_raw.read_text().splitlines()] assert base64.b64decode(event["payload_base64"]) == malformed manifests = list(failed_raw.parent.glob(f"{failed_raw.name}.manifest-*.json")) assert manifests assert any( read_json(path)["response_headers"]["x-local-capture-status"] == "incomplete_capture_failure" for path in manifests ) [failure] = list((tmp_path / "quality").glob("live_depth_capture.*.failed.json")) assert read_json(failure)["completion_manifest_published"] is False def test_raw_journal_publish_recovers_if_manifest_write_fails_after_rename( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: spool = cli_module._RawMessageSpool( root=tmp_path, symbol="BTCUSDT", source_uri="wss://example.invalid/stream", ) spool.append_frame( RawDepthFrame( payload=b"{}", was_text=True, received_ts_ns=1, capture_seq=0, continuity_id="epoch-1", ) ) real_write_manifest = cli_module.write_source_manifest attempts = 0 def flaky_manifest(*args: object, **kwargs: object) -> tuple[Path, str]: nonlocal attempts attempts += 1 if attempts == 1: raise RuntimeError("injected manifest failure") return real_write_manifest(*args, **kwargs) # type: ignore[arg-type] monkeypatch.setattr(cli_module, "write_source_manifest", flaky_manifest) with pytest.raises(RuntimeError, match="injected manifest failure"): spool.publish(status="raw_capture_complete") renamed_path = spool.evidence_path assert renamed_path.is_file() evidence = spool.publish(status="incomplete_capture_failure") assert evidence.path == renamed_path assert evidence.sha256 == sha256_file(renamed_path) assert attempts == 2