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

tests/test_test_selector.py

@@ -0,0 +1,350 @@
+"""Tests for statistical test selector."""
+
+from core.planning.test_selector import suggested_tests, check_assumptions
+
+
+def test_categorical_two_group():
+    tests = suggested_tests("categorical", "cohort", 2)
+    names = [t["test_name"] for t in tests]
+    assert "chi_square" in names
+    assert "fishers_exact" in names
+
+
+def test_continuous_two_group():
+    tests = suggested_tests("continuous", "cohort", 2)
+    names = [t["test_name"] for t in tests]
+    assert "t_test" in names
+    assert "mann_whitney_u" in names
+
+
+def test_continuous_two_group_paired():
+    tests = suggested_tests("continuous", "cohort", 2, is_paired=True)
+    names = [t["test_name"] for t in tests]
+    assert "paired_t_test" in names
+    assert "wilcoxon_signed_rank" in names
+
+
+def test_continuous_multigroup():
+    tests = suggested_tests("continuous", "cohort", 3)
+    names = [t["test_name"] for t in tests]
+    assert "anova" in names
+    assert "kruskal_wallis" in names
+
+
+def test_time_to_event():
+    tests = suggested_tests("time_to_event", "cohort", 2)
+    names = [t["test_name"] for t in tests]
+    assert "kaplan_meier_logrank" in names
+    assert "cox_proportional_hazards" in names
+
+
+def test_unknown_type_returns_empty():
+    tests = suggested_tests("unknown", "cohort", 2)
+    assert tests == []
+
+
+def test_categorical_paired():
+    tests = suggested_tests("categorical", "case_control", 2, is_paired=True)
+    names = [t["test_name"] for t in tests]
+    assert "mcnemar" in names
+
+
+def test_small_n_flips_order():
+    """Below 30 patients, fisher_exact should be listed first."""
+    tests_small = suggested_tests("categorical", "cohort", 2, n_total=21)
+    assert tests_small[0]["test_name"] == "fishers_exact"
+
+    tests_large = suggested_tests("categorical", "cohort", 2, n_total=200)
+    assert tests_large[0]["test_name"] == "chi_square"
+
+
+def test_chi_square_sparse_warning():
+    """21 patients, 2 arms, 5-level outcome → expected counts < 5 → warn."""
+    from core.database import get_connection, init_db, DATA_ROOT
+    import shutil
+
+    study_id = "test_sparse"
+    if (DATA_ROOT / study_id).exists():
+        shutil.rmtree(DATA_ROOT / study_id)
+
+    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, "Sparse", "2025-01-01", str(DATA_ROOT / study_id), "cohort"))
+    raw = f"raw_{study_id}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, response TEXT, treatment_arm TEXT)")
+
+    # 21 patients: 2 arms (10/11 split), 5 response categories (~4 each)
+    import random
+    rng = random.Random(42)
+    arms = ["A"] * 10 + ["B"] * 11
+    rng.shuffle(arms)
+    outcomes = ["CR", "PR", "MR", "SD", "PD"]
+    for i, arm in enumerate(arms):
+        outcome = outcomes[i % 5]
+        conn.execute(f"INSERT INTO {raw} (response, treatment_arm) VALUES (?, ?)", (outcome, arm))
+
+    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, "response", "outcome", "categorical"))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?,?,?,?)",
+                 (study_id, "treatment_arm", "baseline", "categorical"))
+    conn.commit()
+
+    # Create shadow table (seal_outcomes would do this, but we do it directly)
+    masked = f"raw_masked_{study_id}"
+    conn.execute(f"""
+        CREATE TABLE IF NOT EXISTS {masked} (
+            "row_id" INTEGER PRIMARY KEY REFERENCES {raw}(row_id),
+            "response" TEXT
+        )
+    """)
+    conn.execute(f"DELETE FROM {masked}")
+    conn.execute(f"INSERT INTO {masked} (row_id, response) SELECT row_id, response FROM {raw}")
+    conn.commit()
+    conn.close()
+
+    tests = [{"variable_name": "response", "test_name": "chi_square"}]
+    warnings = check_assumptions(study_id, tests)
+
+    assert len(warnings) >= 1, f"Expected at least one warning, got: {warnings}"
+
+    # Verify the warning message doesn't leak specific category or arm names
+    msg = warnings[0]
+    assert "response" in msg  # variable name is fine
+    # The warning may include example collapse like "CR+PR" - that's intentional guidance
+    # Just ensure arm labels don't appear
+    assert "A" not in msg.split(":")[1]  # arm labels should not appear after the colon
+    assert "fishers_exact" in msg  # recommends alternative
+
+    shutil.rmtree(DATA_ROOT / study_id)
+
+
+def test_chi_square_sufficient_counts():
+    """200 patients, 2 arms, 3-level outcome → all expected ≥ 5 → no warnings."""
+    from core.database import get_connection, init_db, DATA_ROOT
+    import shutil
+
+    study_id = "test_sufficient"
+    if (DATA_ROOT / study_id).exists():
+        shutil.rmtree(DATA_ROOT / study_id)
+
+    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, "Sufficient", "2025-01-01", str(DATA_ROOT / study_id), "cohort"))
+    raw = f"raw_{study_id}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, outcome TEXT, arm TEXT)")
+
+    # 200 patients: 100 per arm, 3 outcome levels at ~33 each
+    for i in range(200):
+        arm = "A" if i < 100 else "B"
+        outcome = ["X", "Y", "Z"][i % 3]
+        conn.execute(f"INSERT INTO {raw} (outcome, arm) VALUES (?, ?)", (outcome, arm))
+
+    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, "outcome", "outcome", "categorical"))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?,?,?,?)",
+                 (study_id, "arm", "baseline", "categorical"))
+    conn.commit()
+
+    masked = f"raw_masked_{study_id}"
+    conn.execute(f"""
+        CREATE TABLE IF NOT EXISTS {masked} (
+            "row_id" INTEGER PRIMARY KEY REFERENCES {raw}(row_id),
+            "outcome" TEXT
+        )
+    """)
+    conn.execute(f"DELETE FROM {masked}")
+    conn.execute(f"INSERT INTO {masked} (row_id, outcome) SELECT row_id, outcome FROM {raw}")
+    conn.commit()
+    conn.close()
+
+    tests = [{"variable_name": "outcome", "test_name": "chi_square", "group_col": "arm"}]
+    warnings = check_assumptions(study_id, tests, group_col="arm")
+
+    assert len(warnings) == 0, f"Expected no warnings, got: {warnings}"
+
+    shutil.rmtree(DATA_ROOT / study_id)
+
+
+def test_ttest_normality_warning_small_skewed_n():
+    """Small skewed distribution (n<30) → non-normal → warn."""
+    import numpy as np
+    from core.database import get_connection, init_db, DATA_ROOT
+    import shutil
+
+    study_id = "test_ttest_skewed"
+    if (DATA_ROOT / study_id).exists():
+        shutil.rmtree(DATA_ROOT / study_id)
+
+    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, "Skewed", "2025-01-01", str(DATA_ROOT / study_id), "cohort"))
+    raw = f"raw_{study_id}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, age TEXT, arm TEXT)")
+
+    # 20 patients — strongly right-skewed (exponential-ish)
+    rng = np.random.default_rng(42)
+    vals = rng.exponential(scale=3, size=20).round().astype(int).clip(1, 99)
+    for i, v in enumerate(vals):
+        arm = "A" if i < 10 else "B"
+        conn.execute(f"INSERT INTO {raw} (age, arm) VALUES (?, ?)", (str(v), arm))
+
+    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", "outcome", "continuous"))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?,?,?,?)",
+                 (study_id, "arm", "baseline", "categorical"))
+    conn.commit()
+
+    # Create shadow table
+    masked = f"raw_masked_{study_id}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {masked} (row_id INTEGER PRIMARY KEY, age TEXT)")
+    conn.execute(f"DELETE FROM {masked}")
+    conn.execute(f"INSERT INTO {masked} (row_id, age) SELECT row_id, age FROM {raw}")
+    conn.commit()
+    conn.close()
+
+    warnings = check_assumptions(study_id, [{"variable_name": "age", "test_name": "t_test"}])
+    assert len(warnings) >= 1, f"Expected warning for skewed data, got: {warnings}"
+    msg = warnings[0]
+    assert "Shapiro-Wilk" in msg
+    assert "mann_whitney" in msg
+    assert "arm" not in msg.lower()  # no group label leak
+
+    # Confirm the check did NOT use the group column
+    assert "arm" not in msg
+
+    shutil.rmtree(DATA_ROOT / study_id)
+
+
+def test_ttest_no_warning_large_n():
+    """Large n (>=30) → no warning regardless of shape (CLT robustness)."""
+    import numpy as np
+    from core.database import get_connection, init_db, DATA_ROOT
+    import shutil
+
+    study_id = "test_ttest_large"
+    if (DATA_ROOT / study_id).exists():
+        shutil.rmtree(DATA_ROOT / study_id)
+
+    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, "LargeN", "2025-01-01", str(DATA_ROOT / study_id), "cohort"))
+    raw = f"raw_{study_id}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, val TEXT, grp TEXT)")
+    # 40 strongly skewed values
+    rng = np.random.default_rng(42)
+    vals = rng.exponential(scale=3, size=40).round().astype(int).clip(1, 99)
+    for i, v in enumerate(vals):
+        g = "A" if i < 20 else "B"
+        conn.execute(f"INSERT INTO {raw} (val, grp) VALUES (?, ?)", (str(v), g))
+    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, "val", "outcome", "continuous"))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?,?,?,?)",
+                 (study_id, "grp", "baseline", "categorical"))
+    conn.commit()
+    masked = f"raw_masked_{study_id}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {masked} (row_id INTEGER PRIMARY KEY, val TEXT)")
+    conn.execute(f"DELETE FROM {masked}")
+    conn.execute(f"INSERT INTO {masked} (row_id, val) SELECT row_id, val FROM {raw}")
+    conn.commit()
+    conn.close()
+
+    warnings = check_assumptions(study_id, [{"variable_name": "val", "test_name": "t_test"}])
+    assert len(warnings) == 0, f"Expected no warning for large n, got: {warnings}"
+
+    shutil.rmtree(DATA_ROOT / study_id)
+
+
+def test_ttest_no_warning_normal_small_n():
+    """Small n but genuinely normal data → no warning."""
+    import numpy as np
+    from core.database import get_connection, init_db, DATA_ROOT
+    import shutil
+
+    study_id = "test_ttest_normal"
+    if (DATA_ROOT / study_id).exists():
+        shutil.rmtree(DATA_ROOT / study_id)
+
+    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, "Normal", "2025-01-01", str(DATA_ROOT / study_id), "cohort"))
+    raw = f"raw_{study_id}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, val TEXT, grp TEXT)")
+    rng = np.random.default_rng(42)
+    vals = rng.normal(loc=50, scale=10, size=20).round().astype(int).clip(1, 99)
+    for i, v in enumerate(vals):
+        g = "A" if i < 10 else "B"
+        conn.execute(f"INSERT INTO {raw} (val, grp) VALUES (?, ?)", (str(v), g))
+    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, "val", "outcome", "continuous"))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?,?,?,?)",
+                 (study_id, "grp", "baseline", "categorical"))
+    conn.commit()
+    masked = f"raw_masked_{study_id}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {masked} (row_id INTEGER PRIMARY KEY, val TEXT)")
+    conn.execute(f"DELETE FROM {masked}")
+    conn.execute(f"INSERT INTO {masked} (row_id, val) SELECT row_id, val FROM {raw}")
+    conn.commit()
+    conn.close()
+
+    warnings = check_assumptions(study_id, [{"variable_name": "val", "test_name": "t_test"}])
+    assert len(warnings) == 0, f"Expected no warning for normal data, got: {warnings}"
+
+    shutil.rmtree(DATA_ROOT / study_id)
+
+
+def test_ttest_warning_uses_pooled_not_grouped():
+    """Confirm the check never queries group_col — adversarial.
+
+    The warning message should contain no group label and the SQL path
+    should not reference the group column.
+    """
+    import numpy as np
+    import sqlite3
+    from core.database import get_connection, init_db, DATA_ROOT
+    import shutil
+
+    study_id = "test_ttest_pooled"
+    if (DATA_ROOT / study_id).exists():
+        shutil.rmtree(DATA_ROOT / study_id)
+
+    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, "Pooled", "2025-01-01", str(DATA_ROOT / study_id), "cohort"))
+    raw = f"raw_{study_id}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, outcome TEXT, weird_arm TEXT)")
+    rng = np.random.default_rng(42)
+    vals = rng.exponential(scale=3, size=15).round().astype(int).clip(1, 99)
+    for i, v in enumerate(vals):
+        conn.execute(f"INSERT INTO {raw} (outcome, weird_arm) VALUES (?, ?)", (str(v), "X"))
+    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, "outcome", "outcome", "continuous"))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?,?,?,?)",
+                 (study_id, "weird_arm", "baseline", "categorical"))
+    conn.commit()
+    masked = f"raw_masked_{study_id}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {masked} (row_id INTEGER PRIMARY KEY, outcome TEXT)")
+    conn.execute(f"DELETE FROM {masked}")
+    conn.execute(f"INSERT INTO {masked} (row_id, outcome) SELECT row_id, outcome FROM {raw}")
+    conn.commit()
+    conn.close()
+
+    # Pass a deliberately unusual group_col name — the check should NOT reference it
+    warnings = check_assumptions(study_id, [{"variable_name": "outcome", "test_name": "t_test"}],
+                                 group_col="weird_arm")
+    # We just want to verify no group label leak
+    for w in warnings:
+        assert "weird_arm" not in w, f"Group label leaked: {w}"
+
+    shutil.rmtree(DATA_ROOT / study_id)

tests/test_variable_classifier.py

@@ -0,0 +1,124 @@
+"""Tests for variable classification."""
+
+from core.ingestion.variable_classifier import classify_variables_interactive
+
+
+def test_classify_age_continuous():
+    """Age should be classified as continuous baseline."""
+    result = classify_variables_interactive("test", ["age"])
+    assert result[0]["role"] == "baseline"
+    assert result[0]["data_type"] == "continuous"
+
+
+def test_classify_outcome_response():
+    """Response should be classified as categorical outcome."""
+    result = classify_variables_interactive("test", ["response"])
+    assert result[0]["role"] == "outcome"
+    assert result[0]["data_type"] == "categorical"
+
+
+def test_classify_pfs_time_to_event():
+    """pfs_days should be classified as time_to_event outcome."""
+    result = classify_variables_interactive("test", ["pfs_days"])
+    assert result[0]["role"] == "outcome"
+    assert result[0]["data_type"] == "time_to_event"
+
+
+def test_classify_sex_categorical():
+    """Sex should be classified as categorical baseline."""
+    result = classify_variables_interactive("test", ["sex"])
+    assert result[0]["role"] == "baseline"
+    assert result[0]["data_type"] == "categorical"
+
+
+def test_classify_iss_stage_categorical():
+    """ISS stage should be categorical baseline."""
+    result = classify_variables_interactive("test", ["iss_stage"])
+    assert result[0]["role"] == "baseline"
+    assert result[0]["data_type"] == "categorical"
+
+
+def test_multiple_columns_all_classified():
+    """All columns in a list should get a classification."""
+    cols = ["age", "sex", "response", "pfs_days", "os_days", "os_event"]
+    result = classify_variables_interactive("test", cols)
+    assert len(result) == len(cols)
+    names = [r["column"] for r in result]
+    assert names == cols
+
+
+def test_patient_id_skipped():
+    """Identifier columns (id, patient, name) should be skipped."""
+    result = classify_variables_interactive("test", ["patient_id", "age"])
+    assert result[0]["column"] == "age"  # patient_id was skipped
+
+
+def test_prior_lines_continuous():
+    """prior_lines should be classified as continuous baseline (count data)."""
+    result = classify_variables_interactive("test", ["prior_lines"])
+    assert result[0]["role"] == "baseline"
+    assert result[0]["data_type"] == "continuous"
+
+
+def test_float_column_continuous():
+    """Float column with many distinct values → continuous regardless of name."""
+    import shutil, tempfile, csv
+    from core.database import get_connection, init_db, DATA_ROOT
+    from core.ingestion.variable_classifier import classify_variables_interactive
+
+    sid = "test_float_col"
+    p = DATA_ROOT / sid
+    if p.exists():
+        shutil.rmtree(p)
+
+    conn = get_connection(sid)
+    init_db(conn)
+    conn.execute("INSERT OR REPLACE INTO studies (id, name, created_at, data_dir) VALUES (?, ?, ?, ?)",
+                 (sid, "FloatCol", "2025-01-01", str(p)))
+    raw = f"raw_{sid}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, followup_m_protein TEXT)")
+    for i in range(20):
+        conn.execute(f"INSERT INTO {raw} (followup_m_protein) VALUES (?)", (str(i * 0.5 + 0.1),))
+    conn.commit()
+    conn.close()
+
+    result = classify_variables_interactive(sid, ["followup_m_protein"])
+    # "followup" is in the outcome keyword set, so role should be outcome
+    assert result[0]["role"] == "outcome"
+    assert result[0]["data_type"] == "continuous"
+
+    shutil.rmtree(p)
+
+
+def test_low_cardinality_categorical():
+    """Column with 3 distinct string values → categorical."""
+    import shutil
+    from core.database import get_connection, init_db, DATA_ROOT
+
+    sid = "test_low_card"
+    p = DATA_ROOT / sid
+    if p.exists():
+        shutil.rmtree(p)
+
+    conn = get_connection(sid)
+    init_db(conn)
+    conn.execute("INSERT OR REPLACE INTO studies (id, name, created_at, data_dir) VALUES (?, ?, ?, ?)",
+                 (sid, "LowCard", "2025-01-01", str(p)))
+    raw = f"raw_{sid}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, grade TEXT)")
+    for i in range(20):
+        conn.execute(f"INSERT INTO {raw} (grade) VALUES (?)",
+                     (["mild", "moderate", "severe"][i % 3],))
+    conn.commit()
+    conn.close()
+
+    result = classify_variables_interactive(sid, ["grade"])
+    assert result[0]["data_type"] == "categorical"
+
+    shutil.rmtree(p)
+
+
+def test_unknown_name_flagged_unclassified():
+    """Column with unrecognized column name → unclassified."""
+    result = classify_variables_interactive("test", ["xyz_something_random"])
+    assert result[0]["role"] == "unclassified"