Microstructure/tests/test_pipeline.py

from __future__ import annotations

import json
import shutil
from pathlib import Path

import polars as pl
import pytest

from microstructure.config import ProjectConfig, load_config
from microstructure.pipeline import PipelineError, reproduce
from microstructure.reporting import ChecksumMismatchError, load_run_bundle


def _config(project_root: Path) -> ProjectConfig:
    config_path = project_root / "configs" / "pipeline-smoke.toml"
    config_path.parent.mkdir(parents=True, exist_ok=True)
    config_path.write_text(
        """
[run]
name = "pipeline-smoke"
evidence_tier = "SYNTHETIC_SMOKE"
seed = 20260807

[data]
mode = "synthetic"
source = "synthetic_pipeline_fixture_v1"
symbols = ["BTCUSDT", "ETHUSDT"]
start = "2024-01-02T00:00:00Z"
events_per_symbol = 72
partition_root = "data/normalized"
schema_version = "1.0.0"

[quality]
max_spread_bps = 100.0
max_silence_ms = 5000
fail_on_error = true

[features]
trade_windows = [2, 4]
volatility_window = 4
intensity_window = 3
label_horizon_events = 2
large_trade_quantile = 0.95

[evaluation]
min_train_events = 24
validation_events = 12
test_events = 12
step_events = 12
embargo_events = 2
bootstrap_samples = 8
calibration_bins = 5

[models]
selection_metric = "log_loss"
logistic_c_values = [1.0]
tree_max_depth_values = [2]
tree_min_samples_leaf = 2

[execution]
decision_latency_events = 1
order_latency_events = 1
maker_fee_bps = 1.0
taker_fee_bps = 4.0
half_spread_bps = 1.0
slippage_bps_per_unit = 0.20
signal_threshold = 0.52
max_position_units = 0.01
order_size_units = 0.002
limit_fill_base_probability = 0.55
queue_ahead_units = 0.001
limit_max_age_events = 5
cancel_latency_events = 1
liquidate_at_end = true
capacity_multipliers = [0.5, 1.0]
""".strip()
        + "\n",
        encoding="utf-8",
    )
    return load_config(config_path)


@pytest.fixture(scope="module")
def completed_bundle(
    tmp_path_factory: pytest.TempPathFactory,
) -> tuple[ProjectConfig, Path]:
    project_root = tmp_path_factory.mktemp("pipeline-project")
    config = _config(project_root)
    run_dir = project_root / "artifacts" / "runs" / "pipeline-smoke"
    return config, reproduce(config, run_dir)


def _read_json(path: Path) -> object:
    return json.loads(path.read_text(encoding="utf-8"))


def test_reproduce_builds_verified_honestly_labeled_vertical_slice(
    completed_bundle: tuple[ProjectConfig, Path],
) -> None:
    config, run_dir = completed_bundle
    bundle = load_run_bundle(run_dir)

    assert bundle.evidence_tier == "SYNTHETIC_SMOKE"
    assert bundle.manifest["data"]["mode"] == "synthetic"
    assert bundle.provenance["requested_evidence_tier"] == "SYNTHETIC_SMOKE"
    assert bundle.provenance["effective_evidence_tier"] == "SYNTHETIC_SMOKE"
    assert bundle.manifest["run_key"] == bundle.provenance["run_key"]
    assert len(str(bundle.manifest["run_key"])) == 64
    assert len(bundle.provenance["input_manifest_sha256"]) == 2
    assert bundle.observed_start_utc < bundle.observed_end_utc
    assert bundle.quality["summary"]["errors"] == 0
    assert bundle.manifest["research"]["feature_ready_rows"] > 0

    normalized_parts = sorted((run_dir / "data" / "normalized").rglob("*.parquet"))
    normalized_manifests = sorted((run_dir / "data" / "normalized").rglob("*.json"))
    assert normalized_parts
    assert normalized_manifests
    assert (run_dir / "research" / "research_frame.parquet").is_file()
    evaluation = pl.read_parquet(run_dir / "research" / "evaluation_frame.parquet")
    assert evaluation.get_column("feature_ready").all()
    assert evaluation.height == bundle.manifest["research"]["evaluation_rows"]
    folds = _read_json(run_dir / "research" / "folds.json")
    assert isinstance(folds, dict)
    assert folds["index_basis"].startswith("zero-based row positions")
    recorded_indices = [
        int(index)
        for fold in folds["folds"]
        for key in ("train_indices", "validation_indices")
        for index in fold[key]
    ]
    recorded_indices.extend(int(index) for index in folds["final_train_indices"])
    recorded_indices.extend(int(index) for index in folds["test_indices"])
    assert recorded_indices
    assert min(recorded_indices) >= 0
    assert max(recorded_indices) < evaluation.height
    assert (run_dir / "research" / "folds.json").is_file()
    analysis_manifest = _read_json(run_dir / "analysis" / "manifest.json")
    assert isinstance(analysis_manifest, dict)
    assert analysis_manifest["descriptive_only"] is True
    assert analysis_manifest["economic_claim_authorized"] is False
    assert analysis_manifest["threshold_source"] == "final_training_period_only"
    expected_analysis = {
        "intraday_liquidity",
        "ofi_future_return",
        "signal_decay_curve",
        "signal_half_life",
        "event_time_impact_labels",
        "large_trade_price_impact",
        "liquidity_recovery",
        "market_regimes",
        "regime_outcomes",
        "regime_model_performance",
        "cross_instrument_stability",
        "feature_stability",
    }
    assert set(analysis_manifest["artifacts"]) == expected_analysis
    assert all((run_dir / "analysis" / f"{name}.parquet").is_file() for name in expected_analysis)
    regime_performance = pl.read_parquet(run_dir / "analysis/regime_model_performance.parquet")
    assert regime_performance.get_column("split").unique().to_list() == ["test"]
    assert set(regime_performance.get_column("threshold_source")) == {
        "caller_supplied_final_training_period"
    }

    families = {str(row["family"]) for row in bundle.predictive_metrics}
    assert families == {"baseline", "logistic", "logistic_l2", "shallow_tree"}
    assert {str(row["split"]) for row in bundle.predictive_metrics} == {
        "validation",
        "test",
    }
    test_metric_rows = [row for row in bundle.predictive_metrics if row["split"] == "test"]
    assert {int(row["bootstrap_block_width_events"]) for row in test_metric_rows} == {4}
    assert {str(row["bootstrap_block_policy"]) for row in test_metric_rows} == {
        "pooled_dense_decision_time_clusters_2x_label_horizon"
    }
    all_predictions = pl.read_parquet(run_dir / "models" / "predictions.parquet")
    assert (
        all_predictions.group_by("decision_ts_ns")
        .agg(pl.col("bootstrap_block").n_unique().alias("block_count"))
        .filter(pl.col("block_count") != 1)
        .is_empty()
    )
    selected = pl.read_parquet(run_dir / "models" / "selected_test_predictions.parquet")
    assert selected.get_column("model").n_unique() == 1
    assert selected.get_column("split").unique().to_list() == ["test"]
    assert selected.get_column("is_oos").all()
    assert selected.get_column("continuity_id").null_count() == 0

    execution_events = pl.read_parquet(run_dir / "execution" / "events.parquet")
    assert execution_events.filter(pl.col("event_ts_ns") != pl.col("decision_ts_ns")).is_empty()
    assert {str(row["order_type"]) for row in bundle.execution_metrics} == {
        "market",
        "limit",
    }
    sensitivity = _read_json(run_dir / "metrics" / "execution_sensitivity.json")
    assert isinstance(sensitivity, list)
    assert {str(row["order_type"]) for row in sensitivity} == {"market", "limit"}
    assert {float(row["size_multiplier"]) for row in sensitivity} == {0.5, 1.0}

    technical = (run_dir / "reports" / "technical_report.md").read_text(encoding="utf-8")
    memo = (run_dir / "reports" / "executive_memo.md").read_text(encoding="utf-8")
    table = (run_dir / "reports" / "model_comparison.md").read_text(encoding="utf-8")
    for rendered in (technical, memo, table):
        assert "SYNTHETIC SMOKE" in rendered
    assert "NOT EMPIRICAL OR INVESTMENT EVIDENCE" in technical
    assert "authorize no capital deployment" in memo
    assert "No capital recommendation is made" in technical

    checksums_before = (run_dir / "checksums.sha256").read_bytes()
    success_mtime = (run_dir / "_SUCCESS").stat().st_mtime_ns
    assert reproduce(config, run_dir) == run_dir
    assert (run_dir / "checksums.sha256").read_bytes() == checksums_before
    assert (run_dir / "_SUCCESS").stat().st_mtime_ns == success_mtime
    assert not list(run_dir.parent.glob(".pipeline-smoke.staging-*"))


def test_checksum_corruption_is_rejected_without_overwrite(
    completed_bundle: tuple[ProjectConfig, Path], tmp_path: Path
) -> None:
    config, source = completed_bundle
    corrupted = tmp_path / "corrupted-run"
    shutil.copytree(source, corrupted)
    metrics_path = corrupted / "metrics" / "execution_metrics.json"
    original = metrics_path.read_bytes()
    metrics_path.write_bytes(original + b"\n")

    with pytest.raises(ChecksumMismatchError, match="checksum mismatch"):
        reproduce(config, corrupted)
    assert metrics_path.read_bytes() == original + b"\n"


def test_independent_runs_have_deterministic_semantic_metrics(
    completed_bundle: tuple[ProjectConfig, Path],
) -> None:
    config, first = completed_bundle
    second = reproduce(config, first.parent / "pipeline-smoke-repeat")

    assert (
        _read_json(first / "run_manifest.json")["run_key"]
        == _read_json(second / "run_manifest.json")["run_key"]
    )
    assert (
        _read_json(first / "provenance.json")["run_key_inputs"]
        == _read_json(second / "provenance.json")["run_key_inputs"]
    )

    for relative in (
        "metrics/predictive_metrics.json",
        "metrics/execution_metrics.json",
        "metrics/execution_sensitivity.json",
    ):
        assert _read_json(first / relative) == _read_json(second / relative)


def test_existing_incomplete_target_is_not_repaired_or_overwritten(
    completed_bundle: tuple[ProjectConfig, Path], tmp_path: Path
) -> None:
    config, _ = completed_bundle
    target = tmp_path / "incomplete"
    target.mkdir()
    marker = target / "producer-failed.txt"
    marker.write_text("preserve me\n", encoding="utf-8")

    with pytest.raises(PipelineError, match="not a verified completed bundle"):
        reproduce(config, target)
    assert marker.read_text(encoding="utf-8") == "preserve me\n"


def test_completed_target_from_different_config_is_not_reused(
    completed_bundle: tuple[ProjectConfig, Path], tmp_path: Path
) -> None:
    config, target = completed_bundle
    alternate_path = tmp_path / "alternate.toml"
    alternate_path.write_text(
        config.path.read_text(encoding="utf-8").replace("seed = 20260807", "seed = 20260808"),
        encoding="utf-8",
    )
    alternate = load_config(alternate_path)

    with pytest.raises(PipelineError, match="different configuration"):
        reproduce(alternate, target)


def test_completed_target_from_different_source_tree_is_not_reused(
    completed_bundle: tuple[ProjectConfig, Path],
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    config, target = completed_bundle
    monkeypatch.setattr(
        "microstructure.pipeline.git_source_tree_sha256",
        lambda project_root: "f" * 64,
    )

    with pytest.raises(PipelineError, match="different Git/source-tree state"):
        reproduce(config, target)


def test_synthetic_reproduction_rejects_public_manifest_anchor(
    completed_bundle: tuple[ProjectConfig, Path], tmp_path: Path
) -> None:
    config, _ = completed_bundle

    with pytest.raises(PipelineError, match="does not accept a public input manifest"):
        reproduce(
            config,
            tmp_path / "wrongly-anchored",
            ingestion_manifest_path=tmp_path / "ingestion.json",
            ingestion_manifest_sha256="a" * 64,
        )


def test_public_reproduction_requires_and_hashes_explicit_manifest_anchor(
    tmp_path: Path,
) -> None:
    config = load_config(Path(__file__).parents[1] / "configs" / "public_sample.toml")
    target = tmp_path / "public-run"

    with pytest.raises(PipelineError, match="requires an explicit ingestion manifest"):
        reproduce(config, target)

    manifest = tmp_path / "ingestion.json"
    manifest.write_text("{}\n", encoding="utf-8")
    with pytest.raises(PipelineError, match="bytes do not match"):
        reproduce(
            config,
            target,
            ingestion_manifest_path=manifest,
            ingestion_manifest_sha256="a" * 64,
        )