tests/test_ge_export.py

"""Tests for GE ML export module.

Tests split generation, conflict resolution, and control negatives
using a small synthetic database.
"""

from pathlib import Path

import numpy as np
import pandas as pd
import pytest

from negbiodb_depmap.depmap_db import get_connection, run_ge_migrations, refresh_all_ge_pairs
from negbiodb_depmap.export import (
    apply_split_to_dataset,
    build_ge_m1,
    build_ge_m2,
    export_ge_negatives,
    generate_cold_both_split,
    generate_cold_cell_line_split,
    generate_cold_gene_split,
    generate_degree_balanced_split,
    generate_random_split,
    generate_uniform_random_negatives,
)

MIGRATIONS_DIR = Path(__file__).parent.parent / "migrations_depmap"


@pytest.fixture
def tmp_db(tmp_path):
    db_path = tmp_path / "test_ge.db"
    run_ge_migrations(db_path, MIGRATIONS_DIR)
    return db_path


@pytest.fixture
def seeded_db(tmp_db):
    """DB with 3 genes × 3 cell lines = 6 negative pairs."""
    conn = get_connection(tmp_db)
    # Genes
    conn.execute("INSERT INTO genes (gene_id, entrez_id, gene_symbol, is_reference_nonessential) VALUES (1, 1001, 'GeneA', 1)")
    conn.execute("INSERT INTO genes (gene_id, entrez_id, gene_symbol) VALUES (2, 1002, 'GeneB')")
    conn.execute("INSERT INTO genes (gene_id, entrez_id, gene_symbol, is_common_essential) VALUES (3, 1003, 'GeneC', 1)")

    # Cell lines
    conn.execute("INSERT INTO cell_lines (cell_line_id, model_id, lineage) VALUES (1, 'ACH-001', 'Lung')")
    conn.execute("INSERT INTO cell_lines (cell_line_id, model_id, lineage) VALUES (2, 'ACH-002', 'Breast')")
    conn.execute("INSERT INTO cell_lines (cell_line_id, model_id, lineage) VALUES (3, 'ACH-003', 'Skin')")

    # Screen
    conn.execute(
        """INSERT INTO ge_screens (screen_id, source_db, depmap_release, screen_type, algorithm)
        VALUES (1, 'depmap', 'test', 'crispr', 'Chronos')"""
    )

    # 6 negative results (GeneA in 3 CLs, GeneB in 3 CLs)
    for gene_id in [1, 2]:
        for cl_id in [1, 2, 3]:
            effect = 0.05 if gene_id == 1 else -0.4
            conn.execute(
                """INSERT INTO ge_negative_results
                (gene_id, cell_line_id, screen_id, gene_effect_score, dependency_probability,
                 evidence_type, confidence_tier, source_db, source_record_id, extraction_method)
                VALUES (?, ?, 1, ?, 0.1, 'crispr_nonessential', 'silver',
                        'depmap', ?, 'score_threshold')""",
                (gene_id, cl_id, effect, f"r{gene_id}_{cl_id}"),
            )

    conn.commit()
    refresh_all_ge_pairs(conn)
    conn.commit()
    conn.close()
    return tmp_db


# ── Split tests ───────────────────────────────────────────────────────────


class TestRandomSplit:
    def test_all_pairs_assigned(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            result = generate_random_split(conn, seed=42)
            total = sum(result["counts"].values())
            assert total == 6
        finally:
            conn.close()

    def test_fold_coverage(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            result = generate_random_split(conn, seed=42)
            assert set(result["counts"].keys()).issubset({"train", "val", "test"})
        finally:
            conn.close()


class TestColdGeneSplit:
    def test_all_pairs_assigned(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            result = generate_cold_gene_split(conn, seed=42)
            total = sum(result["counts"].values())
            assert total == 6
        finally:
            conn.close()

    def test_no_gene_leakage(self, seeded_db):
        """Test genes in train should not appear in test."""
        conn = get_connection(seeded_db)
        try:
            result = generate_cold_gene_split(conn, seed=42)
            split_id = result["split_id"]

            train_genes = {
                r[0] for r in conn.execute(
                    """SELECT DISTINCT p.gene_id
                    FROM ge_split_assignments sa
                    JOIN gene_cell_pairs p ON sa.pair_id = p.pair_id
                    WHERE sa.split_id = ? AND sa.fold = 'train'""",
                    (split_id,),
                ).fetchall()
            }
            test_genes = {
                r[0] for r in conn.execute(
                    """SELECT DISTINCT p.gene_id
                    FROM ge_split_assignments sa
                    JOIN gene_cell_pairs p ON sa.pair_id = p.pair_id
                    WHERE sa.split_id = ? AND sa.fold = 'test'""",
                    (split_id,),
                ).fetchall()
            }
            assert len(train_genes & test_genes) == 0
        finally:
            conn.close()


class TestColdCellLineSplit:
    def test_all_pairs_assigned(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            result = generate_cold_cell_line_split(conn, seed=42)
            total = sum(result["counts"].values())
            assert total == 6
        finally:
            conn.close()

    def test_no_cell_line_leakage(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            result = generate_cold_cell_line_split(conn, seed=42)
            split_id = result["split_id"]

            train_cls = {
                r[0] for r in conn.execute(
                    """SELECT DISTINCT p.cell_line_id
                    FROM ge_split_assignments sa
                    JOIN gene_cell_pairs p ON sa.pair_id = p.pair_id
                    WHERE sa.split_id = ? AND sa.fold = 'train'""",
                    (split_id,),
                ).fetchall()
            }
            test_cls = {
                r[0] for r in conn.execute(
                    """SELECT DISTINCT p.cell_line_id
                    FROM ge_split_assignments sa
                    JOIN gene_cell_pairs p ON sa.pair_id = p.pair_id
                    WHERE sa.split_id = ? AND sa.fold = 'test'""",
                    (split_id,),
                ).fetchall()
            }
            assert len(train_cls & test_cls) == 0
        finally:
            conn.close()


class TestColdBothSplit:
    def test_all_pairs_assigned(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            result = generate_cold_both_split(conn, seed=42)
            total = sum(result["counts"].values())
            assert total == 6
        finally:
            conn.close()


class TestDegreeBalancedSplit:
    def test_all_pairs_assigned(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            result = generate_degree_balanced_split(conn, seed=42)
            total = sum(result["counts"].values())
            assert total == 6
        finally:
            conn.close()


# ── Export tests ──────────────────────────────────────────────────────────


class TestExport:
    def test_export_parquet(self, seeded_db, tmp_path):
        conn = get_connection(seeded_db)
        try:
            generate_random_split(conn, seed=42)
            out = tmp_path / "export" / "pairs.parquet"
            count = export_ge_negatives(conn, out)
            assert count == 6
            assert out.exists()
            df = pd.read_parquet(out)
            assert "gene_symbol" in df.columns
            assert "model_id" in df.columns
            assert "split_random_v1" in df.columns
        finally:
            conn.close()


# ── M1/M2 tests ──────────────────────────────────────────────────────────


class TestBuildM1:
    def test_basic_m1(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            pos_df = pd.DataFrame({
                "gene_id": [3, 3],
                "cell_line_id": [1, 2],
                "essentiality_type": ["common_essential", "common_essential"],
            })
            neg_df = pd.DataFrame({
                "gene_id": [1, 1, 2],
                "cell_line_id": [1, 2, 1],
            })
            result = build_ge_m1(conn, pos_df, neg_df, balanced=True, ratio=1.0)
            assert (result["label"] == 1).sum() == 2
            assert (result["label"] == 0).sum() == 2
        finally:
            conn.close()

    def test_conflict_resolution(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            # Gene 1 in CL 1 appears in both positive and negative
            pos_df = pd.DataFrame({
                "gene_id": [1, 3],
                "cell_line_id": [1, 1],
                "essentiality_type": ["selective_essential", "common_essential"],
            })
            neg_df = pd.DataFrame({
                "gene_id": [1, 2],
                "cell_line_id": [1, 1],
            })
            result = build_ge_m1(conn, pos_df, neg_df, balanced=False)
            # (1, 1) conflict → removed from both
            assert len(result) == 2  # gene3-cl1 pos + gene2-cl1 neg
        finally:
            conn.close()


class TestBuildM2:
    def test_three_classes(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            pos_df = pd.DataFrame({
                "gene_id": [3, 2],
                "cell_line_id": [1, 3],
                "essentiality_type": ["common_essential", "selective_essential"],
            })
            neg_df = pd.DataFrame({
                "gene_id": [1],
                "cell_line_id": [1],
            })
            result = build_ge_m2(conn, pos_df, neg_df)
            assert (result["label"] == 0).sum() == 1  # common essential
            assert (result["label"] == 1).sum() == 1  # selective essential
            assert (result["label"] == 2).sum() == 1  # non-essential
        finally:
            conn.close()


# ── apply_split_to_dataset tests ─────────────────────────────────────────


class TestApplySplitToDataset:
    """Test dataset-level split application for ML training."""

    @pytest.fixture
    def combined_df(self):
        """Combined pos+neg DataFrame with 100 rows, 5 genes × 4 cell lines."""
        rng = np.random.RandomState(0)
        n = 100
        genes = rng.choice([1, 2, 3, 4, 5], n)
        cls = rng.choice([10, 20, 30, 40], n)
        return pd.DataFrame({
            "gene_id": genes,
            "cell_line_id": cls,
            "label": rng.choice([0, 1], n),
            "gene_degree": rng.randint(1, 2000, n),
        })

    def test_random_split_coverage(self, combined_df):
        result = apply_split_to_dataset(combined_df, "random", seed=42)
        assert "split" in result.columns
        assert set(result["split"].unique()) == {"train", "val", "test"}
        assert len(result) == len(combined_df)

    def test_random_split_ratios(self, combined_df):
        result = apply_split_to_dataset(combined_df, "random", seed=42)
        n = len(combined_df)
        assert abs(sum(result["split"] == "train") - int(n * 0.7)) <= 1
        assert abs(sum(result["split"] == "val") - int(n * 0.1)) <= 1

    def test_cold_gene_no_leakage(self, combined_df):
        result = apply_split_to_dataset(combined_df, "cold_gene", seed=42)
        train_genes = set(result.loc[result["split"] == "train", "gene_id"])
        test_genes = set(result.loc[result["split"] == "test", "gene_id"])
        assert len(train_genes & test_genes) == 0

    def test_cold_cell_line_no_leakage(self, combined_df):
        result = apply_split_to_dataset(combined_df, "cold_cell_line", seed=42)
        train_cls = set(result.loc[result["split"] == "train", "cell_line_id"])
        test_cls = set(result.loc[result["split"] == "test", "cell_line_id"])
        assert len(train_cls & test_cls) == 0

    def test_cold_both_metis_property(self):
        """In Metis-style: train pairs have both entities in train partition."""
        rng = np.random.RandomState(0)
        n = 500
        # Use enough entities so val partition isn't empty (5% of 20 = 1)
        genes = rng.choice(range(1, 21), n)
        cls = rng.choice(range(100, 121), n)
        df = pd.DataFrame({
            "gene_id": genes,
            "cell_line_id": cls,
            "label": rng.choice([0, 1], n),
        })
        result = apply_split_to_dataset(df, "cold_both", seed=42)
        assert set(result["split"].unique()) == {"train", "val", "test"}
        assert len(result) == n

    def test_degree_balanced_coverage(self, combined_df):
        result = apply_split_to_dataset(combined_df, "degree_balanced", seed=42)
        assert set(result["split"].unique()) == {"train", "val", "test"}
        assert len(result) == len(combined_df)

    def test_different_splits_differ(self, combined_df):
        """Different strategies should produce different assignments."""
        r1 = apply_split_to_dataset(combined_df, "random", seed=42)
        r2 = apply_split_to_dataset(combined_df, "cold_gene", seed=42)
        # At least some rows should differ
        assert not (r1["split"] == r2["split"]).all()

    def test_different_seeds_differ(self, combined_df):
        r1 = apply_split_to_dataset(combined_df, "random", seed=42)
        r2 = apply_split_to_dataset(combined_df, "random", seed=99)
        assert not (r1["split"] == r2["split"]).all()

    def test_same_seed_reproducible(self, combined_df):
        r1 = apply_split_to_dataset(combined_df, "cold_gene", seed=42)
        r2 = apply_split_to_dataset(combined_df, "cold_gene", seed=42)
        assert (r1["split"] == r2["split"]).all()

    def test_unknown_strategy_raises(self, combined_df):
        with pytest.raises(ValueError, match="Unknown split strategy"):
            apply_split_to_dataset(combined_df, "bogus")

    def test_degree_balanced_no_degree_col_falls_back(self):
        """Without gene_degree column, should fall back to random."""
        df = pd.DataFrame({
            "gene_id": [1, 2, 3, 4],
            "cell_line_id": [10, 20, 30, 40],
            "label": [0, 1, 0, 1],
        })
        result = apply_split_to_dataset(df, "degree_balanced", seed=42)
        assert "split" in result.columns


# ── Control negatives ─────────────────────────────────────────────────────


class TestControlNegatives:
    def test_uniform_random(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            result = generate_uniform_random_negatives(conn, n_samples=5, seed=42)
            assert len(result) <= 5
            assert "neg_source" in result.columns
            assert all(result["neg_source"] == "uniform_random")
        finally:
            conn.close()

    def test_no_overlap_with_existing(self, seeded_db):
        conn = get_connection(seeded_db)
        try:
            existing = set()
            for row in conn.execute(
                "SELECT gene_id, cell_line_id FROM gene_cell_pairs"
            ).fetchall():
                existing.add((row[0], row[1]))

            result = generate_uniform_random_negatives(conn, n_samples=5, seed=42)
            for _, r in result.iterrows():
                assert (r["gene_id"], r["cell_line_id"]) not in existing
        finally:
            conn.close()