Datasets:
Formats:
parquet
Languages:
English
Size:
10M - 100M
Tags:
biology
chemistry
drug-discovery
clinical-trials
protein-protein-interaction
gene-essentiality
License:
| """Tests for AACT ETL pipeline.""" | |
| import sqlite3 | |
| from pathlib import Path | |
| import pandas as pd | |
| import pytest | |
| from negbiodb_ct.ct_db import create_ct_database, get_connection, refresh_all_ct_pairs | |
| from negbiodb_ct.etl_aact import ( | |
| BATCH_SIZE, | |
| normalize_phase, | |
| normalize_sponsor_type, | |
| normalize_intervention_type, | |
| parse_aact_date, | |
| prepare_interventions, | |
| prepare_conditions, | |
| prepare_trials, | |
| insert_interventions, | |
| insert_conditions, | |
| insert_trials, | |
| insert_trial_junctions, | |
| load_aact_table, | |
| ) | |
| MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations_ct" | |
| def ct_db(tmp_path): | |
| """Create a fresh CT database with all migrations applied.""" | |
| db_path = tmp_path / "test_ct.db" | |
| create_ct_database(db_path, MIGRATIONS_DIR) | |
| return db_path | |
| # ============================================================ | |
| # TRANSFORM TESTS | |
| # ============================================================ | |
| class TestNormalizePhase: | |
| def test_phase_1(self): | |
| assert normalize_phase("Phase 1") == "phase_1" | |
| def test_phase_1_2(self): | |
| assert normalize_phase("Phase 1/Phase 2") == "phase_1_2" | |
| def test_phase_2(self): | |
| assert normalize_phase("Phase 2") == "phase_2" | |
| def test_phase_3(self): | |
| assert normalize_phase("Phase 3") == "phase_3" | |
| def test_phase_4(self): | |
| assert normalize_phase("Phase 4") == "phase_4" | |
| def test_early_phase_1(self): | |
| assert normalize_phase("Early Phase 1") == "early_phase_1" | |
| def test_not_applicable(self): | |
| assert normalize_phase("Not Applicable") == "not_applicable" | |
| def test_none(self): | |
| assert normalize_phase(None) is None | |
| def test_empty(self): | |
| assert normalize_phase("") is None | |
| def test_nan_float(self): | |
| assert normalize_phase(float("nan")) is None | |
| def test_unknown(self): | |
| assert normalize_phase("Phase 5") is None | |
| class TestNormalizeSponsorType: | |
| def test_industry(self): | |
| assert normalize_sponsor_type("Industry") == "industry" | |
| def test_nih(self): | |
| assert normalize_sponsor_type("NIH") == "government" | |
| def test_us_fed(self): | |
| assert normalize_sponsor_type("U.S. Fed") == "government" | |
| def test_other(self): | |
| assert normalize_sponsor_type("Other") == "other" | |
| def test_none(self): | |
| assert normalize_sponsor_type(None) == "other" | |
| def test_unknown_value(self): | |
| assert normalize_sponsor_type("BigPharma Inc") == "other" | |
| class TestNormalizeInterventionType: | |
| def test_drug(self): | |
| assert normalize_intervention_type("Drug") == "drug" | |
| def test_biological(self): | |
| assert normalize_intervention_type("Biological") == "biologic" | |
| def test_device(self): | |
| assert normalize_intervention_type("Device") == "device" | |
| def test_combination(self): | |
| assert normalize_intervention_type("Combination Product") == "combination" | |
| def test_dietary(self): | |
| assert normalize_intervention_type("Dietary Supplement") == "dietary" | |
| def test_none(self): | |
| assert normalize_intervention_type(None) == "other" | |
| def test_unknown(self): | |
| assert normalize_intervention_type("Quantum Therapy") == "other" | |
| class TestParseAactDate: | |
| def test_month_year(self): | |
| assert parse_aact_date("January 2020") == "2020-01-01" | |
| def test_full_date(self): | |
| assert parse_aact_date("March 15, 2021") == "2021-03-15" | |
| def test_iso_format(self): | |
| assert parse_aact_date("2022-05-01") == "2022-05-01" | |
| def test_none(self): | |
| assert parse_aact_date(None) is None | |
| def test_empty(self): | |
| assert parse_aact_date("") is None | |
| def test_nan_float(self): | |
| assert parse_aact_date(float("nan")) is None | |
| def test_december(self): | |
| assert parse_aact_date("December 2023") == "2023-12-01" | |
| # ============================================================ | |
| # PREPARE TESTS | |
| # ============================================================ | |
| class TestPrepareInterventions: | |
| def test_deduplicates_by_name_and_type(self): | |
| df = pd.DataFrame({ | |
| "nct_id": ["NCT001", "NCT002", "NCT003"], | |
| "intervention_type": ["Drug", "Drug", "Biological"], | |
| "name": ["Aspirin", "aspirin", "Aspirin"], | |
| "description": ["desc1", "desc2", "desc3"], | |
| }) | |
| browse = pd.DataFrame(columns=["nct_id", "mesh_term"]) | |
| result = prepare_interventions(df, browse) | |
| # "Aspirin" + Drug should dedup, but "Aspirin" + Biological is different | |
| assert len(result) == 2 | |
| def test_skips_nan_names(self): | |
| df = pd.DataFrame({ | |
| "nct_id": ["NCT001", "NCT002"], | |
| "intervention_type": ["Drug", "Drug"], | |
| "name": ["Aspirin", float("nan")], | |
| "description": ["d1", "d2"], | |
| }) | |
| browse = pd.DataFrame(columns=["nct_id", "mesh_term"]) | |
| result = prepare_interventions(df, browse) | |
| assert len(result) == 1 | |
| def test_enriches_with_mesh(self): | |
| df = pd.DataFrame({ | |
| "nct_id": ["NCT001"], | |
| "intervention_type": ["Drug"], | |
| "name": ["Aspirin"], | |
| "description": ["d1"], | |
| }) | |
| browse = pd.DataFrame({ | |
| "nct_id": ["NCT001"], | |
| "mesh_term": ["Aspirin"], | |
| }) | |
| result = prepare_interventions(df, browse) | |
| assert result[0]["mesh_id"] == "Aspirin" | |
| class TestPrepareConditions: | |
| def test_deduplicates_by_name(self): | |
| df = pd.DataFrame({ | |
| "nct_id": ["NCT001", "NCT002"], | |
| "name": ["Diabetes", "diabetes"], | |
| }) | |
| browse = pd.DataFrame(columns=["nct_id", "mesh_term"]) | |
| result = prepare_conditions(df, browse) | |
| assert len(result) == 1 | |
| # ============================================================ | |
| # LOAD TESTS (with DB) | |
| # ============================================================ | |
| class TestInsertInterventions: | |
| def test_basic_insert(self, ct_db): | |
| conn = get_connection(ct_db) | |
| try: | |
| items = [ | |
| {"intervention_type": "drug", "intervention_name": "Imatinib", "mesh_id": None}, | |
| {"intervention_type": "biologic", "intervention_name": "Trastuzumab", "mesh_id": "D00123"}, | |
| ] | |
| name_to_id = insert_interventions(conn, items) | |
| assert len(name_to_id) == 2 | |
| assert "imatinib" in name_to_id | |
| assert "trastuzumab" in name_to_id | |
| finally: | |
| conn.close() | |
| def test_dedup_same_name(self, ct_db): | |
| conn = get_connection(ct_db) | |
| try: | |
| items = [ | |
| {"intervention_type": "drug", "intervention_name": "Aspirin", "mesh_id": None}, | |
| {"intervention_type": "drug", "intervention_name": "Aspirin", "mesh_id": None}, | |
| ] | |
| name_to_id = insert_interventions(conn, items) | |
| assert len(name_to_id) == 1 | |
| finally: | |
| conn.close() | |
| class TestInsertConditions: | |
| def test_basic_insert(self, ct_db): | |
| conn = get_connection(ct_db) | |
| try: | |
| items = [ | |
| {"condition_name": "Diabetes", "mesh_id": None}, | |
| {"condition_name": "Cancer", "mesh_id": "D009369"}, | |
| ] | |
| name_to_id = insert_conditions(conn, items) | |
| assert len(name_to_id) == 2 | |
| assert "diabetes" in name_to_id | |
| finally: | |
| conn.close() | |
| class TestInsertTrials: | |
| def test_basic_insert(self, ct_db): | |
| conn = get_connection(ct_db) | |
| try: | |
| trials = [ | |
| { | |
| "source_db": "clinicaltrials_gov", | |
| "source_trial_id": "NCT00000001", | |
| "overall_status": "Completed", | |
| "trial_phase": "phase_3", | |
| "study_design": None, | |
| "blinding": None, | |
| "randomized": 1, | |
| "enrollment_actual": 500, | |
| "sponsor_type": "industry", | |
| "sponsor_name": "TestPharma", | |
| "start_date": "2020-01-01", | |
| "primary_completion_date": "2022-06-01", | |
| "completion_date": "2022-12-01", | |
| "why_stopped": None, | |
| "has_results": 1, | |
| }, | |
| ] | |
| nct_to_id = insert_trials(conn, trials) | |
| assert len(nct_to_id) == 1 | |
| assert "NCT00000001" in nct_to_id | |
| finally: | |
| conn.close() | |
| def test_unique_constraint_on_nct(self, ct_db): | |
| """Duplicate nct_id should be ignored (INSERT OR IGNORE).""" | |
| conn = get_connection(ct_db) | |
| try: | |
| trial = { | |
| "source_db": "clinicaltrials_gov", | |
| "source_trial_id": "NCT00000001", | |
| "overall_status": "Completed", | |
| "trial_phase": "phase_3", | |
| "study_design": None, "blinding": None, | |
| "randomized": 0, "enrollment_actual": None, | |
| "sponsor_type": "other", "sponsor_name": None, | |
| "start_date": None, "primary_completion_date": None, | |
| "completion_date": None, "why_stopped": None, | |
| "has_results": 0, | |
| } | |
| nct_to_id1 = insert_trials(conn, [trial]) | |
| nct_to_id2 = insert_trials(conn, [trial]) | |
| # Should get same ID back | |
| assert nct_to_id1["NCT00000001"] == nct_to_id2["NCT00000001"] | |
| finally: | |
| conn.close() | |
| class TestInsertTrialJunctions: | |
| def test_links_created(self, ct_db): | |
| conn = get_connection(ct_db) | |
| try: | |
| # Set up data | |
| conn.execute( | |
| "INSERT INTO interventions (intervention_type, intervention_name) " | |
| "VALUES ('drug', 'DrugA')" | |
| ) | |
| conn.execute( | |
| "INSERT INTO conditions (condition_name) VALUES ('DiseaseX')" | |
| ) | |
| conn.execute( | |
| "INSERT INTO clinical_trials " | |
| "(source_db, source_trial_id, overall_status) " | |
| "VALUES ('clinicaltrials_gov', 'NCT001', 'Completed')" | |
| ) | |
| conn.commit() | |
| raw_interv = pd.DataFrame({ | |
| "nct_id": ["NCT001"], | |
| "name": ["DrugA"], | |
| "intervention_type": ["Drug"], | |
| }) | |
| raw_cond = pd.DataFrame({ | |
| "nct_id": ["NCT001"], | |
| "name": ["DiseaseX"], | |
| }) | |
| n_ti, n_tc = insert_trial_junctions( | |
| conn, raw_interv, raw_cond, | |
| nct_to_trial_id={"NCT001": 1}, | |
| name_to_intervention_id={"druga": 1}, | |
| name_to_condition_id={"diseasex": 1}, | |
| ) | |
| assert n_ti == 1 | |
| assert n_tc == 1 | |
| finally: | |
| conn.close() | |
| class TestLoadAactTable: | |
| def test_loads_pipe_delimited(self, tmp_path): | |
| """Test loading a pipe-delimited file.""" | |
| test_file = tmp_path / "test_table.txt" | |
| test_file.write_text("col1|col2|col3\nA|B|C\nD|E|F\n") | |
| df = load_aact_table(tmp_path, "test_table") | |
| assert len(df) == 2 | |
| assert list(df.columns) == ["col1", "col2", "col3"] | |
| def test_file_not_found(self, tmp_path): | |
| with pytest.raises(FileNotFoundError): | |
| load_aact_table(tmp_path, "nonexistent") | |