research-tool-cli 0.1.0__py3-none-any.whl

tests/test_manuscript_draft.py

@@ -0,0 +1,289 @@
+"""Tests for manuscript draft limitations generation."""
+
+from __future__ import annotations
+
+import json
+import shutil
+
+import pandas as pd
+import pytest
+
+from core.database import get_connection, init_db, DATA_ROOT
+from core.planning.lock import lock_plan
+from core.planning.study_plan import StudyPlan
+from core.reporting.manuscript_draft import (
+    generate_key_results, generate_limitations, generate_draft,
+)
+
+
+STUDY_ID = "test_draft_limitations"
+
+
+def _setup_study(seed_vars: bool = True):
+    p = DATA_ROOT / STUDY_ID
+    if p.exists():
+        shutil.rmtree(p)
+    p.mkdir(parents=True)
+
+    conn = get_connection(STUDY_ID)
+    init_db(conn)
+    conn.execute(
+        "INSERT OR REPLACE INTO studies (id, name, created_at, data_dir, study_type) VALUES (?, ?, ?, ?, ?)",
+        (STUDY_ID, "Limitations Test", "2025-01-01", str(p), "cohort"),
+    )
+    raw = f"raw_{STUDY_ID}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, age TEXT, response TEXT, treatment_arm TEXT)")
+    conn.execute(f"INSERT INTO {raw} (age, response, treatment_arm) VALUES ('65', 'CR', 'A')")
+    conn.execute(f"INSERT INTO {raw} (age, response, treatment_arm) VALUES ('70', 'PR', 'B')")
+    if seed_vars:
+        conn.execute("DELETE FROM variables WHERE study_id=?", (STUDY_ID,))
+        conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?,?,?,?)",
+                     (STUDY_ID, "age", "baseline", "continuous"))
+        conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?,?,?,?)",
+                     (STUDY_ID, "response", "outcome", "categorical"))
+    conn.commit()
+    conn.close()
+
+
+def _add_skipped_result():
+    conn = get_connection(STUDY_ID)
+    init_db(conn)
+    conn.execute(
+        """INSERT INTO analysis_results
+           (study_id, test_name, statistic, p_value, status_json,
+            sample_counts_json, is_pre_registered, computed_at)
+           VALUES (?, ?, ?, ?, ?, ?, 1, ?)""",
+        (STUDY_ID, "chi_square", None, None,
+         json.dumps({"status": "skipped_assumption_violation",
+                     "reason": "minimum expected cell count is 1.4 (below 5 threshold)"}),
+         json.dumps({"n_total": 21, "n_analyzed": 0, "n_excluded": 21}),
+         "2025-01-01T00:00:00"),
+    )
+    conn.commit()
+    conn.close()
+
+
+def _add_completed_result():
+    conn = get_connection(STUDY_ID)
+    init_db(conn)
+    conn.execute(
+        """INSERT INTO analysis_results
+           (study_id, test_name, statistic, p_value, status_json,
+            sample_counts_json, is_pre_registered, computed_at)
+           VALUES (?, ?, ?, ?, ?, ?, 1, ?)""",
+        (STUDY_ID, "t_test", 2.5, 0.02,
+         json.dumps({"status": "completed", "reason": None}),
+         json.dumps({"n_total": 100, "n_analyzed": 95, "n_excluded": 5}),
+         "2025-01-01T00:00:00"),
+    )
+    conn.commit()
+    conn.close()
+
+
+def test_skipped_test_produces_limitations():
+    _setup_study()
+    plan = StudyPlan(study_id=STUDY_ID, study_type="cohort", primary_comparison="test",
+                     planned_tests=[{"variable_name": "response", "test_name": "chi_square"}])
+    lock_plan(STUDY_ID, plan)
+    _add_skipped_result()
+
+    text = generate_limitations(STUDY_ID)
+    assert "chi_square" in text
+    assert "expected cell count" in text
+    assert "exploratory only" in text
+    assert ".;" not in text
+
+
+def test_no_skipped_no_fabricated():
+    """No skipped tests, adequate sample → no fabricated limitation."""
+    _setup_study()
+    plan = StudyPlan(study_id=STUDY_ID, study_type="cohort", primary_comparison="test")
+    lock_plan(STUDY_ID, plan)
+    _add_completed_result()
+
+    text = generate_limitations(STUDY_ID)
+    # Should have the generic retrospective limitation
+    assert "retrospective" in text
+    # Should NOT have any skipped-test limitation
+    assert "exploratory" not in text
+    # Should NOT fabricate a limitation about small sample (n>=50)
+    assert "limits statistical power" not in text
+
+
+def test_placeholders_preserved():
+    """Introduction, Interpretation, Generalisability remain placeholders."""
+    _setup_study()
+    lock_plan(STUDY_ID, StudyPlan(study_id=STUDY_ID, study_type="cohort"))
+    _add_completed_result()
+
+    # Test limitations function directly — doesn't require Table 1 data
+    text = generate_limitations(STUDY_ID)
+    assert "retrospective" in text
+    # n=100 is >= 50 so no sample-size limitation should appear
+    assert "limits statistical power" not in text
+    assert "exploratory" not in text
+
+
+def test_forced_warning_is_reported_from_planned_test_variable():
+    _setup_study()
+    plan = StudyPlan(
+        study_id=STUDY_ID,
+        study_type="cohort",
+        primary_comparison="response by arm",
+        planned_tests=[{"variable_name": "response", "test_name": "chi_square"}],
+        warnings={"response": "minimum expected cell count is 1.4"},
+    )
+    lock_plan(STUDY_ID, plan)
+    conn = get_connection(STUDY_ID)
+    conn.execute(
+        """INSERT INTO analysis_results
+           (study_id, test_name, statistic, p_value, status_json,
+            sample_counts_json, is_pre_registered, computed_at)
+           VALUES (?, ?, ?, ?, ?, ?, 1, ?)""",
+        (STUDY_ID, "chi_square", 0.4, 0.5,
+         json.dumps({"status": "completed", "reason": None}),
+         json.dumps({"n_total": 21, "n_analyzed": 21, "n_excluded": 0}),
+         "2025-01-01T00:00:00"),
+    )
+    conn.commit()
+    conn.close()
+
+    text = generate_limitations(STUDY_ID)
+    assert "performed despite a flagged assumption violation" in text
+    assert "minimum expected cell count" in text
+
+
+def test_cox_epv_uses_events_not_observations():
+    _setup_study()
+    conn = get_connection(STUDY_ID)
+    conn.execute("ALTER TABLE raw_test_draft_limitations ADD COLUMN pfs_days TEXT")
+    conn.execute("ALTER TABLE raw_test_draft_limitations ADD COLUMN pfs_event TEXT")
+    conn.execute("UPDATE raw_test_draft_limitations SET pfs_days='100', pfs_event='0'")
+    conn.execute("UPDATE raw_test_draft_limitations SET pfs_event='1' WHERE row_id=1")
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?, ?, ?, ?)",
+                 (STUDY_ID, "pfs_days", "outcome", "time_to_event"))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?, ?, ?, ?)",
+                 (STUDY_ID, "pfs_event", "outcome", "categorical"))
+    conn.commit()
+    conn.close()
+    plan = StudyPlan(
+        study_id=STUDY_ID,
+        study_type="cohort",
+        primary_comparison="PFS by arm",
+        planned_tests=[{"variable_name": "pfs_days", "test_name": "cox_proportional_hazards"}],
+        covariates=[1],
+    )
+    lock_plan(STUDY_ID, plan)
+    conn = get_connection(STUDY_ID)
+    conn.execute(
+        """INSERT INTO analysis_results
+           (study_id, test_name, statistic, p_value, status_json,
+            sample_counts_json, is_pre_registered, computed_at)
+           VALUES (?, ?, ?, ?, ?, ?, 1, ?)""",
+        (STUDY_ID, "cox_proportional_hazards", 1.2, 0.8,
+         json.dumps({"status": "completed", "reason": None}),
+         json.dumps({"n_total": 100, "n_analyzed": 100, "n_excluded": 0}),
+         "2025-01-01T00:00:00"),
+    )
+    conn.commit()
+    conn.close()
+
+    text = generate_limitations(STUDY_ID)
+    assert "EPV=0.5" in text
+    assert "events across 2 predictors" in text
+
+
+def test_key_results_counts_statuses_without_editorializing():
+    assert generate_key_results([
+        {"is_pre_registered": 1, "status_json": json.dumps({"status": "completed"})},
+        {"is_pre_registered": 1, "status_json": json.dumps({"status": "skipped_assumption_violation"})},
+    ]) == (
+        "**Key results:** Of 2 pre-registered test(s), 1 completed successfully "
+        "and 1 was skipped due to an assumption violation."
+    )
+
+
+# ── Fix 1: MultiIndex column flattening ──────────────────────────────────
+
+def test_table1_multiindex_columns_flattened(monkeypatch):
+    """Table 1 with MultiIndex columns should be flattened before markdown rendering."""
+    _setup_study()
+    lock_plan(STUDY_ID, StudyPlan(study_id=STUDY_ID, study_type="cohort", primary_comparison="test"))
+
+    # Create a DataFrame with MultiIndex columns like tableone produces
+    idx = pd.Index(["age", "sex"], name="variable")
+    cols = pd.MultiIndex.from_tuples([
+        ("Grouped by treatment_arm", "Missing"),
+        ("Grouped by treatment_arm", "Overall"),
+        ("Grouped by treatment_arm", "A"),
+        ("Grouped by treatment_arm", "B"),
+    ])
+    fake_tbl = pd.DataFrame(
+        [["2 (10.0%)", "21", "10", "11"],
+         ["21 (100.0%)", "21", "10", "11"]],
+        index=idx, columns=cols,
+    )
+
+    def mock_table1(study_id, groupby=None):
+        return fake_tbl
+
+    monkeypatch.setattr("core.stats.descriptive.generate_table1", mock_table1)
+
+    draft = generate_draft(STUDY_ID)
+    # No tuple strings in the output
+    assert "('Grouped" not in draft
+    assert "'Missing'" not in draft
+    # Clean headers should appear
+    assert "Missing" in draft
+    assert "Overall" in draft
+
+
+def test_table1_hierarchical_markdown_formatting(monkeypatch):
+    """Categorical variables in Table 1 should render bold parent header and indented child rows."""
+    _setup_study()
+    lock_plan(STUDY_ID, StudyPlan(study_id=STUDY_ID, study_type="cohort", primary_comparison="test"))
+
+    idx = pd.MultiIndex.from_tuples([
+        ("high_risk_fish, n (%)", "no"),
+        ("high_risk_fish, n (%)", "yes"),
+    ])
+    cols = ["Missing", "Overall", "A", "B"]
+    fake_tbl = pd.DataFrame(
+        [["0", "12 (57.1)", "6 (60.0)", "6 (54.5)"],
+         ["0", "9 (42.9)", "4 (40.0)", "5 (45.5)"]],
+        index=idx, columns=cols,
+    )
+
+    monkeypatch.setattr("core.stats.descriptive.generate_table1", lambda study_id, groupby=None: fake_tbl)
+
+    draft = generate_draft(STUDY_ID)
+    assert "**high_risk_fish, n (%)**" in draft
+    assert "  no" in draft
+    assert "  yes" in draft
+
+
+# ── Fix 2: Abstract hydration ─────────────────────────────────────────────
+
+def test_abstract_hydrated_with_analysis_results():
+    """Abstract's Results line should use real analysis counts, not a placeholder."""
+    _setup_study()
+    lock_plan(STUDY_ID, StudyPlan(study_id=STUDY_ID, study_type="cohort", primary_comparison="test"))
+    _add_skipped_result()
+    _add_completed_result()
+
+    draft = generate_draft(STUDY_ID)
+
+    # Should NOT contain the old placeholder
+    assert "[Results summary" not in draft
+    # 1 skipped + 1 completed = 1 of 2 completed
+    assert "1 of 2 pre-registered tests completed" in draft
+
+
+def test_abstract_placeholder_when_no_analyses():
+    """Abstract should keep placeholder when no analysis results exist."""
+    _setup_study()
+    lock_plan(STUDY_ID, StudyPlan(study_id=STUDY_ID, study_type="cohort", primary_comparison="test"))
+
+    draft = generate_draft(STUDY_ID)
+
+    assert "[Results summary" in draft

tests/test_masking_gate.py

@@ -0,0 +1,196 @@
+"""Adversarial tests for the masking gate.
+
+The gate MUST prevent outcome data access at the physical storage level.
+
+Tests:
+  1. Raw sqlite3 SELECT on outcome columns pre-classify → visible (not yet sealed)
+  2. After classify + seal → outcome columns are NULL in the raw table
+  3. After lock → still NULL
+  4. After unmask → outcome data restored
+  5. Direct sqlite3 CLI attack → still NULL (storage-level, not proxy-level)
+  6. No outcome columns → no interference
+"""
+
+from __future__ import annotations
+import json
+import sqlite3
+from pathlib import Path
+
+import pytest
+
+from core.database import get_connection, init_db, DATA_ROOT
+from core.masking.gate import seal_outcomes, unmask_study, lock_study, is_masked
+from core.ingestion.variable_classifier import _classify_batch
+
+TEST_STUDY_ID = "test_masking_001"
+RAW_TABLE = f"raw_{TEST_STUDY_ID}"
+MASKED_TABLE = f"raw_masked_{TEST_STUDY_ID}"
+
+
+@pytest.fixture(autouse=True)
+def _setup():
+    conn = get_connection(TEST_STUDY_ID)
+    init_db(conn)
+    conn.execute(
+        "INSERT OR REPLACE INTO studies (id, name, created_at, data_dir, is_locked) VALUES (?, ?, ?, ?, ?)",
+        (TEST_STUDY_ID, "Test Study", "2025-01-01T00:00:00",
+         str(Path("data/studies") / TEST_STUDY_ID), 0),
+    )
+    # Create raw table with outcome columns that have actual values
+    conn.execute(f"""
+        CREATE TABLE IF NOT EXISTS {RAW_TABLE} (
+            "row_id" INTEGER PRIMARY KEY,
+            "age" TEXT,
+            "response" TEXT,
+            "pfs_days" TEXT
+        )
+    """)
+    conn.execute(f"DELETE FROM {RAW_TABLE}")
+    for i in range(3):
+        conn.execute(
+            f"INSERT INTO {RAW_TABLE} (age, response, pfs_days) VALUES (?, ?, ?)",
+            (str(65 + i), "CR" if i == 0 else "PR", str(300 + i)),
+        )
+    conn.commit()
+    conn.close()
+    yield
+    import shutil
+    p = DATA_ROOT / TEST_STUDY_ID
+    if p.exists():
+        shutil.rmtree(p)
+
+
+def _classify(study_id, variables):
+    """Helper to classify variables and seal outcomes."""
+    _classify_batch(study_id, variables)
+    seal_outcomes(study_id)
+
+
+def test_raw_outcomes_visible_before_seal():
+    """Before sealing, outcome values are visible in the raw table."""
+    # Classify but don't seal yet
+    _classify_batch(TEST_STUDY_ID, [
+        {"column": "age", "role": "baseline", "data_type": "continuous"},
+        {"column": "response", "role": "outcome", "data_type": "categorical"},
+        {"column": "pfs_days", "role": "outcome", "data_type": "continuous"},
+    ])
+    conn = get_connection(TEST_STUDY_ID)
+    cur = conn.execute(f"SELECT response, pfs_days FROM {RAW_TABLE}")
+    rows = cur.fetchall()
+    conn.close()
+    for r in rows:
+        assert r["response"] is not None, "pre-seal outcomes should be visible"
+        assert r["pfs_days"] is not None
+
+
+def test_outcomes_nulled_after_seal():
+    """After seal_outcomes(), outcome values are physically NULL in the raw table."""
+    _classify_batch(TEST_STUDY_ID, [
+        {"column": "age", "role": "baseline", "data_type": "continuous"},
+        {"column": "response", "role": "outcome", "data_type": "categorical"},
+        {"column": "pfs_days", "role": "outcome", "data_type": "continuous"},
+    ])
+    seal_outcomes(TEST_STUDY_ID)
+
+    # Direct conn — no proxy
+    conn = get_connection(TEST_STUDY_ID)
+    cur = conn.execute(f"SELECT age, response, pfs_days FROM {RAW_TABLE}")
+    rows = cur.fetchall()
+    conn.close()
+    for r in rows:
+        assert r["age"] is not None, "baseline should be visible"
+        assert r["response"] is None, f"outcome should be NULL after seal, got {r['response']}"
+        assert r["pfs_days"] is None
+
+
+def test_sqlite3_cli_bypass_still_null():
+    """Even direct sqlite3 CLI (simulated via sqlite3 module) sees NULLs after seal."""
+    _classify_batch(TEST_STUDY_ID, [
+        {"column": "age", "role": "baseline", "data_type": "continuous"},
+        {"column": "response", "role": "outcome", "data_type": "categorical"},
+        {"column": "pfs_days", "role": "outcome", "data_type": "continuous"},
+    ])
+    seal_outcomes(TEST_STUDY_ID)
+
+    # Connect with raw sqlite3, not through our code
+    db_path = DATA_ROOT / TEST_STUDY_ID / "study.db"
+    raw_conn = sqlite3.connect(str(db_path))
+    raw_conn.row_factory = sqlite3.Row
+    cur = raw_conn.execute(f"SELECT response, pfs_days FROM {RAW_TABLE}")
+    rows = cur.fetchall()
+    raw_conn.close()
+    for r in rows:
+        assert r["response"] is None, "direct sqlite3 should also see NULL"
+        assert r["pfs_days"] is None
+
+
+def test_lock_still_null():
+    """After lock_study(), outcomes remain NULL."""
+    _classify(TEST_STUDY_ID, [
+        {"column": "age", "role": "baseline", "data_type": "continuous"},
+        {"column": "response", "role": "outcome", "data_type": "categorical"},
+        {"column": "pfs_days", "role": "outcome", "data_type": "continuous"},
+    ])
+    lock_study(TEST_STUDY_ID)
+    conn = get_connection(TEST_STUDY_ID)
+    cur = conn.execute(f"SELECT response FROM {RAW_TABLE}")
+    rows = cur.fetchall()
+    conn.close()
+    for r in rows:
+        assert r["response"] is None
+
+
+def test_unmask_restores_values():
+    """After unmask_study(), outcome values are restored in the raw table."""
+    _classify(TEST_STUDY_ID, [
+        {"column": "age", "role": "baseline", "data_type": "continuous"},
+        {"column": "response", "role": "outcome", "data_type": "categorical"},
+        {"column": "pfs_days", "role": "outcome", "data_type": "continuous"},
+    ])
+    unmask_study(TEST_STUDY_ID)
+    conn = get_connection(TEST_STUDY_ID)
+    cur = conn.execute(f"SELECT age, response, pfs_days FROM {RAW_TABLE} ORDER BY row_id")
+    rows = cur.fetchall()
+    conn.close()
+    assert rows[0]["response"] == "CR"
+    assert rows[1]["response"] == "PR"
+    assert rows[0]["pfs_days"] == "300"
+
+
+def test_is_masked_after_seal():
+    """is_masked() returns True after sealing, False after unmask."""
+    _classify(TEST_STUDY_ID, [
+        {"column": "age", "role": "baseline", "data_type": "continuous"},
+        {"column": "response", "role": "outcome", "data_type": "categorical"},
+        {"column": "pfs_days", "role": "outcome", "data_type": "continuous"},
+    ])
+    assert is_masked(TEST_STUDY_ID) is True
+    unmask_study(TEST_STUDY_ID)
+    assert is_masked(TEST_STUDY_ID) is False
+
+
+def test_no_outcome_variables_no_effect():
+    """If no outcome columns exist, sealing does nothing."""
+    _classify_batch(TEST_STUDY_ID, [
+        {"column": "age", "role": "baseline", "data_type": "continuous"},
+    ])
+    seal_outcomes(TEST_STUDY_ID)
+    conn = get_connection(TEST_STUDY_ID)
+    cur = conn.execute(f"SELECT age FROM {RAW_TABLE}")
+    row = cur.fetchone()
+    conn.close()
+    assert row["age"] is not None
+
+
+def test_shadow_table_contains_values():
+    """The masked shadow table should have the original values."""
+    _classify(TEST_STUDY_ID, [
+        {"column": "age", "role": "baseline", "data_type": "continuous"},
+        {"column": "response", "role": "outcome", "data_type": "categorical"},
+    ])
+    conn = get_connection(TEST_STUDY_ID)
+    cur = conn.execute(f"SELECT response FROM {MASKED_TABLE} ORDER BY row_id")
+    rows = cur.fetchall()
+    conn.close()
+    assert rows[0]["response"] == "CR"
+    assert rows[1]["response"] == "PR"

tests/test_masking_migration.py

@@ -0,0 +1,111 @@
+"""
+Standalone smoke test for the outcome-masking migration.
+Builds an in-memory throwaway DB matching the migration's shape,
+applies the migration, and asserts the masking invariant holds
+for BOTH the sqlite3 stdlib driver directly (simulating a raw
+CLI-equivalent connection) AND confirms it's not dependent on
+any application wrapper.
+
+Run: python3 test_masking_migration.py
+"""
+import sqlite3
+import sys
+
+SETUP_RAW_TABLE = """
+CREATE TABLE cohort (
+    study_id TEXT,
+    pt_id TEXT,
+    age INTEGER,
+    stage TEXT,
+    treatment TEXT,
+    os_event INTEGER,
+    os_months REAL
+);
+"""
+
+SEED_DATA = """
+INSERT INTO cohort (study_id, pt_id, age, stage, treatment, os_event, os_months)
+VALUES ('study_123', 'P001', 55, 'II', 'ArmA', 1, 14.2),
+       ('study_123', 'P002', 61, 'III', 'ArmB', 0, 22.7);
+"""
+
+MIGRATION = """
+ALTER TABLE cohort RENAME TO _raw_cohort;
+
+CREATE TABLE study_state (
+    study_id TEXT PRIMARY KEY,
+    status TEXT NOT NULL DEFAULT 'unlocked'
+        CHECK (status IN ('unlocked', 'locked', 'amendment_in_progress')),
+    current_plan_hash TEXT,
+    updated_at_utc TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+);
+
+INSERT INTO study_state (study_id, status) VALUES ('study_123', 'unlocked');
+
+CREATE VIEW cohort AS
+SELECT
+    r.pt_id, r.age, r.stage, r.treatment,
+    CASE WHEN (SELECT status FROM study_state WHERE study_id = r.study_id) = 'locked'
+         THEN r.os_event ELSE NULL END AS os_event,
+    CASE WHEN (SELECT status FROM study_state WHERE study_id = r.study_id) = 'locked'
+         THEN r.os_months ELSE NULL END AS os_months
+FROM _raw_cohort r;
+"""
+
+def run():
+    conn = sqlite3.connect(":memory:")
+    conn.executescript(SETUP_RAW_TABLE)
+    conn.executescript(SEED_DATA)
+    conn.executescript(MIGRATION)
+    conn.commit()
+
+    failures = []
+
+    # Test 1: unlocked -> view returns NULL outcome, no wrapper involved
+    rows = conn.execute("SELECT pt_id, os_event, os_months FROM cohort").fetchall()
+    for pt_id, os_event, os_months in rows:
+        if os_event is not None or os_months is not None:
+            failures.append(f"UNLOCKED test FAILED: {pt_id} returned os_event={os_event}, os_months={os_months} (expected NULL)")
+
+    # Test 2: raw table still has real data (expected -- that's the vault, not the leak)
+    raw_rows = conn.execute("SELECT pt_id, os_event FROM _raw_cohort").fetchall()
+    if not any(r[1] is not None for r in raw_rows):
+        failures.append("RAW TABLE test FAILED: expected real values in _raw_cohort, got all NULL")
+
+    # Test 3: lock the study, view should now reveal real values
+    conn.execute("UPDATE study_state SET status = 'locked' WHERE study_id = 'study_123'")
+    conn.commit()
+    rows_locked = conn.execute("SELECT pt_id, os_event, os_months FROM cohort").fetchall()
+    if not any(r[1] is not None for r in rows_locked):
+        failures.append("LOCKED test FAILED: expected real os_event values after lock, got all NULL")
+
+    # Test 4: re-mask on amendment (simulating Autopsy Canvas re-entry)
+    conn.execute("UPDATE study_state SET status = 'amendment_in_progress' WHERE study_id = 'study_123'")
+    conn.commit()
+    rows_amend = conn.execute("SELECT pt_id, os_event FROM cohort").fetchall()
+    if any(r[1] is not None for r in rows_amend):
+        failures.append("AMENDMENT test FAILED: expected re-masking during amendment_in_progress, got real values")
+
+    # Test 5: a second study must not be affected by study_123's lock state
+    conn.execute("INSERT INTO study_state (study_id, status) VALUES ('study_456', 'unlocked')")
+    conn.execute("""INSERT INTO _raw_cohort (study_id, pt_id, age, stage, treatment, os_event, os_months)
+                     VALUES ('study_456', 'Q001', 40, 'I', 'ArmA', 1, 5.0)""")
+    conn.commit()
+    cross_study = conn.execute(
+        "SELECT c.pt_id, c.os_event FROM cohort c JOIN _raw_cohort r USING(pt_id) WHERE r.study_id='study_456'"
+    ).fetchall()
+    if any(r[1] is not None for r in cross_study):
+        failures.append("CROSS-STUDY test FAILED: study_456 (unlocked) leaked real os_event values")
+
+    conn.close()
+
+    if failures:
+        print("FAILURES:")
+        for f in failures:
+            print(" -", f)
+        sys.exit(1)
+    else:
+        print("All masking invariant tests passed.")
+
+if __name__ == "__main__":
+    run()

tests/test_multiple_comparisons.py

@@ -0,0 +1,56 @@
+"""Tests for multiple comparisons correction."""
+
+import pytest
+
+from core.stats.multiple_comparisons import bonferroni, holm_bonferroni, benjamini_hochberg, correct
+
+
+def test_bonferroni_identity():
+    """Single p-value unchanged by Bonferroni."""
+    assert bonferroni([0.05]) == [0.05]
+    assert bonferroni([0.01]) == [0.01]
+
+
+def test_bonferroni_caps_at_one():
+    adjusted = bonferroni([0.5, 0.5])
+    assert all(a == 1.0 for a in adjusted)
+
+
+def test_bonferroni_multiple():
+    adjusted = bonferroni([0.01, 0.03, 0.05])
+    assert adjusted[0] == pytest.approx(0.03)  # 0.01 * 3
+    assert adjusted[1] == pytest.approx(0.09)  # 0.03 * 3
+    assert adjusted[2] == pytest.approx(0.15)  # 0.05 * 3
+
+
+def test_holm_bonferroni():
+    adjusted = holm_bonferroni([0.01, 0.03, 0.05])
+    # After monotonicity enforcement: 0.06, 0.06, 0.05
+    assert adjusted == pytest.approx([0.06, 0.06, 0.05])
+
+
+def test_holm_monotonic():
+    """Holm-Bonferroni adjusted p-values must be non-decreasing."""
+    adjusted = holm_bonferroni([0.001, 0.01, 0.1, 0.5])
+    for i in range(len(adjusted) - 1):
+        assert adjusted[i] <= adjusted[i + 1] + 1e-10
+
+
+def test_benjamini_hochberg():
+    adjusted = benjamini_hochberg([0.01, 0.02, 0.03, 0.04, 0.05])
+    assert all(a <= 1.0 for a in adjusted)
+    assert adjusted[0] <= adjusted[1]  # non-decreasing
+
+
+def test_empty_input():
+    assert bonferroni([]) == []
+    assert holm_bonferroni([]) == []
+    assert benjamini_hochberg([]) == []
+
+
+def test_correct_dispatch():
+    pvals = [0.01, 0.02, 0.03]
+    assert correct(pvals, "bonferroni")[0] == 0.03
+    assert len(correct(pvals, "holm_bonferroni")) == 3
+    assert len(correct(pvals, "benjamini_hochberg")) == 3
+    assert correct(pvals, "unknown") == pvals