Microstructure/tests/test_m8_l2_inputs.py

from __future__ import annotations

import os
import shutil
from dataclasses import replace
from pathlib import Path
from typing import cast

import pyarrow as pa  # type: ignore[import-untyped]
import pyarrow.parquet as pq  # type: ignore[import-untyped]
import pytest

import microstructure.m8_l2_inputs as input_module
import test_m8_l2_capture as capture_fixtures
from microstructure.data.schemas import SCHEMA_VERSION, get_schema
from microstructure.m8_l2_config import M8L2Session, M8L2StudyConfig, load_m8_l2_config
from microstructure.m8_l2_inputs import (
    L2CampaignRuntimeIdentity,
    L2SessionFileAuthority,
    M8L2InputError,
    verify_m8_l2_development_input,
    verify_m8_l2_heldout_input,
)

PROJECT_ROOT = Path(__file__).parents[1]
CONFIG_PATH = PROJECT_ROOT / "configs" / "m8_l2_capture_study.toml"


def _base_record(field: pa.Field) -> object:
    if field.name == "schema_version":
        return SCHEMA_VERSION
    if pa.types.is_string(field.type):
        return "fixture"
    if pa.types.is_integer(field.type):
        return 1
    if pa.types.is_floating(field.type):
        return 1.0
    if pa.types.is_boolean(field.type):
        return True
    if pa.types.is_list(field.type):
        return []
    raise AssertionError(f"unsupported fixture field: {field}")


def _valid_parquet(
    path: Path,
    dataset: str,
    rows: int,
    *,
    session: M8L2Session,
    corrupt_continuity: bool = False,
) -> None:
    schema = get_schema(dataset)
    symbol = next(part for part in path.parts if part in {"BTCUSDT", "ETHUSDT"})
    continuity = f"{symbol}-epoch-1"
    times = [session.start_ns + 10_000_000_000, session.end_ns - 10_000_000_001]
    records: list[dict[str, object]] = []
    for index in range(rows):
        record = {field.name: _base_record(field) for field in schema}
        available = times[min(index, len(times) - 1)]
        record.update(
            {
                "venue": "binance_spot",
                "symbol": symbol,
                "event_ts_ns": available,
                "received_ts_ns": available,
                "available_ts_ns": available,
                "availability_basis": "local_receipt",
                "capture_seq": index + 1,
                "continuity_id": continuity,
                "source_artifact_id": "a" * 64,
                "tick_size": 0.01,
                "lot_size": 0.001,
            }
        )
        if dataset == "depth_deltas":
            record.update(
                {
                    "first_update_id": index + 1,
                    "last_update_id": index + 1,
                    "previous_update_id": index if index else None,
                    "bids": [],
                    "asks": [],
                }
            )
        elif dataset == "book_observations":
            record.update(
                {
                    "continuity_id": "wrong-epoch" if corrupt_continuity else continuity,
                    "sequence_start": index + 1,
                    "sequence_end": index + 1,
                    "is_valid": True,
                    "best_bid_ticks": 10_000,
                    "best_ask_ticks": 10_001,
                    "bid_quantity_lots": 2_000,
                    "ask_quantity_lots": 2_000,
                    "best_bid": 100.0,
                    "best_ask": 100.01,
                    "bid_quantity": 2.0,
                    "ask_quantity": 2.0,
                    "spread": 0.01,
                    "mid_price": 100.005,
                    "microprice": 100.005,
                    "depth_bid_1": 2.0,
                    "depth_ask_1": 2.0,
                    "depth_bid_5": 2.0,
                    "depth_ask_5": 2.0,
                    "depth_bid_10": 2.0,
                    "depth_ask_10": 2.0,
                    "queue_imbalance_1": 0.0,
                    "queue_imbalance_5": 0.0,
                    "queue_imbalance_10": 0.0,
                }
            )
        elif dataset == "book_snapshots":
            record.update(
                {
                    "snapshot_id": f"{symbol}-snapshot",
                    "request_ts_ns": session.start_ns,
                    "received_ts_ns": session.start_ns + 1,
                    "available_ts_ns": session.start_ns + 1,
                    "last_update_id": 0,
                    "depth_limit": 100,
                    "bids": [],
                    "asks": [],
                }
            )
        records.append(record)
    path.parent.mkdir(parents=True, exist_ok=True)
    pq.write_table(pa.Table.from_pylist(records, schema=schema), path)


class _CaptureFactory:
    def __init__(
        self,
        monkeypatch: pytest.MonkeyPatch,
        config: M8L2StudyConfig,
        *,
        corrupt_continuity: bool = False,
    ) -> None:
        self.config = config
        self.session = config.sessions[0]

        def write(path: Path, dataset: str, rows: int) -> None:
            _valid_parquet(
                path,
                dataset,
                rows,
                session=self.session,
                corrupt_continuity=corrupt_continuity,
            )

        monkeypatch.setattr(capture_fixtures, "_parquet", write)

    def capture(self, output_root: Path, session_index: int):
        self.session = self.config.sessions[session_index]
        return capture_fixtures._capture_complete_session(
            output_root,
            config=self.config,
            session=self.session,
        )


@pytest.fixture
def config() -> M8L2StudyConfig:
    return load_m8_l2_config(CONFIG_PATH)


def test_development_input_binds_authority_and_loads_only_requested_symbol(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    config: M8L2StudyConfig,
) -> None:
    factory = _CaptureFactory(monkeypatch, config)
    bundle = factory.capture(tmp_path, 0)
    verified = verify_m8_l2_development_input(
        bundle.root,
        expected_config=config,
        expected_date="2026-08-10",
        expected_role="train",
    )

    assert verified.root == bundle.root
    assert verified.access_phase == "development"
    assert verified.development_lock_sha256 is None
    assert verified.file_authority.manifest_sha256 == bundle.manifest_sha256
    assert verified.file_authority.to_dict() == {
        "manifest_sha256": bundle.manifest_sha256,
        "checksums_sha256": verified.file_authority.checksums_sha256,
    }
    assert verified.campaign_identity.to_dict()["runtime_dirty"] is False
    assert set(verified.symbols) == {"BTCUSDT", "ETHUSDT"}
    assert verified.symbols["BTCUSDT"].depth_deltas.rows == 2
    assert verified.symbols["BTCUSDT"].book_observations.rows == 2

    opened: list[str] = []
    original = input_module._load_verified_parquet
    original_lineage = input_module._verify_artifact_hash

    def recording_loader(*args: object, **kwargs: object):
        artifact = kwargs["artifact"]
        assert isinstance(artifact, input_module.VerifiedL2Artifact)
        opened.append(artifact.relative_path)
        return original(*args, **kwargs)

    def recording_lineage(*args: object, **kwargs: object) -> None:
        artifact = kwargs["artifact"]
        assert isinstance(artifact, input_module.VerifiedL2Artifact)
        opened.append(artifact.relative_path)
        original_lineage(*args, **kwargs)

    monkeypatch.setattr(input_module, "_load_verified_parquet", recording_loader)
    monkeypatch.setattr(input_module, "_verify_artifact_hash", recording_lineage)
    loaded = verified.load_symbol_frames("BTCUSDT")
    assert loaded.book_observations.height == 2
    assert loaded.depth_deltas.height == 2
    assert loaded.intervals == verified.symbols["BTCUSDT"].valid_observed_intervals
    assert len(opened) == 4
    assert all(path.startswith("symbols/BTCUSDT/") for path in opened)
    assert not any("ETHUSDT" in path for path in opened)

    rebound = verify_m8_l2_development_input(
        bundle.root,
        expected_config=config,
        expected_date="2026-08-10",
        expected_role="train",
        expected_file_authority=verified.file_authority,
        expected_campaign=verified.campaign_identity,
    )
    assert rebound.file_authority == verified.file_authority


def test_development_coordinates_are_hard_separated_before_bundle_open(
    tmp_path: Path,
    config: M8L2StudyConfig,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    called = False

    def forbidden(*args: object, **kwargs: object):
        nonlocal called
        called = True
        raise AssertionError("verifier must not open a held-out coordinate through dev API")

    monkeypatch.setattr(input_module, "verify_m8_l2_session_bundle", forbidden)
    with pytest.raises(M8L2InputError, match="development input"):
        verify_m8_l2_development_input(
            tmp_path,
            expected_config=config,
            expected_date="2026-08-12",
            expected_role=cast(input_module.DevelopmentRole, "primary_test"),
        )
    assert called is False


def test_heldout_input_requires_and_binds_development_lock(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    config: M8L2StudyConfig,
) -> None:
    with pytest.raises(M8L2InputError, match="development lock authority"):
        verify_m8_l2_heldout_input(
            tmp_path,
            expected_config=config,
            expected_date="2026-08-12",
            expected_role="primary_test",
            development_lock_sha256="not-a-digest",
        )

    factory = _CaptureFactory(monkeypatch, config)
    bundle = factory.capture(tmp_path, 2)
    lock_sha256 = "d" * 64
    verified = verify_m8_l2_heldout_input(
        bundle.root,
        expected_config=config,
        expected_date="2026-08-12",
        expected_role="primary_test",
        development_lock_sha256=lock_sha256,
    )
    assert verified.access_phase == "heldout_after_lock"
    assert verified.development_lock_sha256 == lock_sha256
    assert verified.load_symbol_frames("ETHUSDT").book_observations.height == 2


def test_cross_session_campaign_identity_must_match(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    config: M8L2StudyConfig,
) -> None:
    factory = _CaptureFactory(monkeypatch, config)
    train = factory.capture(tmp_path, 0)
    train_input = verify_m8_l2_development_input(
        train.root,
        expected_config=config,
        expected_date="2026-08-10",
        expected_role="train",
    )
    validation = factory.capture(tmp_path, 1)
    matching = verify_m8_l2_development_input(
        validation.root,
        expected_config=config,
        expected_date="2026-08-11",
        expected_role="validation",
        expected_campaign=train_input.campaign_identity,
    )
    assert matching.campaign_identity == train_input.campaign_identity

    wrong = replace(
        train_input.campaign_identity,
        runtime_source_tree_sha256="3" * 64,
    )
    with pytest.raises(M8L2InputError, match="campaign/runtime identity"):
        verify_m8_l2_development_input(
            validation.root,
            expected_config=config,
            expected_date="2026-08-11",
            expected_role="validation",
            expected_campaign=wrong,
        )


def test_external_file_authority_mismatch_fails_closed(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    config: M8L2StudyConfig,
) -> None:
    factory = _CaptureFactory(monkeypatch, config)
    bundle = factory.capture(tmp_path, 0)
    wrong = L2SessionFileAuthority("0" * 64, "1" * 64)
    with pytest.raises(M8L2InputError, match="external digest authority"):
        verify_m8_l2_development_input(
            bundle.root,
            expected_config=config,
            expected_date="2026-08-10",
            expected_role="train",
            expected_file_authority=wrong,
        )


def test_insufficient_extra_file_and_symlink_roots_are_rejected(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    config: M8L2StudyConfig,
) -> None:
    factory = _CaptureFactory(monkeypatch, config)
    bundle = factory.capture(tmp_path, 0)

    original_verifier = input_module.verify_m8_l2_session_bundle
    monkeypatch.setattr(
        input_module,
        "verify_m8_l2_session_bundle",
        lambda *args, **kwargs: replace(
            bundle, status="INSUFFICIENT_DATA", reason_codes=("NO_MESSAGES",)
        ),
    )
    with pytest.raises(M8L2InputError, match="gate-complete"):
        verify_m8_l2_development_input(
            bundle.root,
            expected_config=config,
            expected_date="2026-08-10",
            expected_role="train",
        )
    monkeypatch.setattr(input_module, "verify_m8_l2_session_bundle", original_verifier)

    extra = bundle.root / "unmanifested.txt"
    extra.write_text("unexpected", encoding="utf-8")
    with pytest.raises(M8L2InputError, match="capture authority failed verification"):
        verify_m8_l2_development_input(
            bundle.root,
            expected_config=config,
            expected_date="2026-08-10",
            expected_role="train",
        )
    extra.unlink()

    alias = tmp_path / "session-alias"
    alias.symlink_to(bundle.root, target_is_directory=True)
    with pytest.raises(M8L2InputError, match="capture authority failed verification"):
        verify_m8_l2_development_input(
            alias,
            expected_config=config,
            expected_date="2026-08-10",
            expected_role="train",
        )


def test_payload_tamper_after_verification_is_detected_before_rows_return(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    config: M8L2StudyConfig,
) -> None:
    factory = _CaptureFactory(monkeypatch, config)
    bundle = factory.capture(tmp_path, 0)
    verified = verify_m8_l2_development_input(
        bundle.root,
        expected_config=config,
        expected_date="2026-08-10",
        expected_role="train",
    )
    target = bundle.root / verified.symbols["BTCUSDT"].book_observations.relative_path
    target.write_bytes(target.read_bytes() + b"tamper")
    with pytest.raises(M8L2InputError, match=r"Parquet|changed|claimed"):
        verified.load_symbol_frames("BTCUSDT")


def test_loader_rejects_an_object_not_created_by_verifier(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    config: M8L2StudyConfig,
) -> None:
    factory = _CaptureFactory(monkeypatch, config)
    bundle = factory.capture(tmp_path, 0)
    verified = verify_m8_l2_development_input(
        bundle.root,
        expected_config=config,
        expected_date="2026-08-10",
        expected_role="train",
    )
    forged = replace(verified, _verification_token=object())
    with pytest.raises(M8L2InputError, match="verifier-created"):
        forged.load_symbol_frames("BTCUSDT")


def test_descriptor_snapshot_detects_atomic_path_replacement_toctou(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    config: M8L2StudyConfig,
) -> None:
    factory = _CaptureFactory(monkeypatch, config)
    bundle = factory.capture(tmp_path, 0)
    verified = verify_m8_l2_development_input(
        bundle.root,
        expected_config=config,
        expected_date="2026-08-10",
        expected_role="train",
    )
    target = bundle.root / verified.symbols["BTCUSDT"].book_observations.relative_path
    replacement = tmp_path / "replacement.parquet"
    shutil.copy2(target, replacement)
    original_hash = input_module._hash_descriptor
    replaced = False

    target_inode = target.stat().st_ino

    def replace_after_hash(descriptor: int, maximum_bytes: int) -> tuple[str, int]:
        nonlocal replaced
        result = original_hash(descriptor, maximum_bytes)
        if not replaced and os.fstat(descriptor).st_ino == target_inode:
            os.replace(replacement, target)
            replaced = True
        return result

    monkeypatch.setattr(input_module, "_hash_descriptor", replace_after_hash)
    with pytest.raises(M8L2InputError, match="path changed"):
        verified.load_symbol_frames("BTCUSDT")
    assert replaced is True


def test_loaded_row_continuity_must_reconcile_to_verified_intervals(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    config: M8L2StudyConfig,
) -> None:
    factory = _CaptureFactory(monkeypatch, config, corrupt_continuity=True)
    bundle = factory.capture(tmp_path, 0)
    verified = verify_m8_l2_development_input(
        bundle.root,
        expected_config=config,
        expected_date="2026-08-10",
        expected_role="train",
    )
    with pytest.raises(M8L2InputError, match=r"reconcile|OBSERVED interval"):
        verified.load_symbol_frames("BTCUSDT")


def test_campaign_identity_constructor_rejects_dirty_runtime() -> None:
    with pytest.raises(M8L2InputError, match="must be clean"):
        L2CampaignRuntimeIdentity(
            campaign_authority_sha256="a" * 64,
            runtime_commit="b" * 40,
            runtime_source_tree_sha256="c" * 64,
            runtime_fingerprint_sha256="d" * 64,
            runtime_dirty=True,
        )