Rewrite classification tests to use mock paradigm

tests/helpers/constants.py

@@ -492,7 +492,7 @@
         {
             "name": "TEST1",
             "category": "protein_coding",
-            "external_identifiers": [{"ensembl_offset": None}, {"uniprot_offset": None}, {"refseq_offset": None}],
+            "external_identifiers": [],
             "target_sequence": {
                 "sequence_type": "dna",
                 "sequence": "ACGTTT",
@@ -586,10 +586,6 @@
                     "url": TEST_SAVED_TAXONOMY["url"],
                 },
             },
-            # TODO
-            "uniprot_offset": None,
-            "ensembl_offset": None,
-            "refseq_offset": None,
         }
     ],
     "metaAnalyzesScoreSetUrns": [],
@@ -774,9 +770,9 @@
             "fractionFunctionallyAltering": 0.20,
         },
     ],
-    "evidenceStrengths": [3, 2, 1, -1],
-    "thresholds": [1.25, 2.5, 3, 5.5],
-    "positiveLikelihoodRatios": [100, 10, 1, 0.1],
+    "evidenceStrengths": [8, 4, 2, 1, -1, -2, -4, -8],
+    "thresholds": [8, 4, 2, 1, -1, -2, -4, -8],
+    "positiveLikelihoodRatios": [1000, 100, 10, 1, 0.1, 0.01, 0.001, 0.0001],
     "priorProbabilityPathogenicity": 0.20,
 }
 

tests/lib/annotation/test_classification.py

@@ -1,137 +1,55 @@
 import pytest
 
-from humps import camelize
-from sqlalchemy import select
 from mavedb.lib.annotation.classification import functional_classification_of_variant
-from mavedb.models.variant import Variant as VariantDbModel
-from mavedb.models.mapped_variant import MappedVariant as MappedVariantDbModel
-from mavedb.models.score_set import ScoreSet as ScoreSetDbModel
 from ga4gh.va_spec.profiles.assay_var_effect import AveFunctionalClassification, AveClinicalClassification
 from mavedb.lib.annotation.classification import pillar_project_clinical_classification_of_variant
 
-from tests.helpers.constants import (
-    TEST_SCORE_CALIBRATION,
-    TEST_SCORE_SET_RANGE,
-)
-from tests.helpers.dependency_overrider import DependencyOverrider
-from tests.helpers.util import add_thresholds_to_score_set, create_experiment, create_seq_score_set_with_mapped_variants
-
 
 @pytest.mark.parametrize(
-    "file_path,expected_classification",
+    "score,expected_classification",
     [
-        ("scores_indeterminate.csv", AveFunctionalClassification.INDETERMINATE),
-        ("scores_normal.csv", AveFunctionalClassification.NORMAL),
-        ("scores_abnormal.csv", AveFunctionalClassification.ABNORMAL),
+        (0, AveFunctionalClassification.INDETERMINATE),
+        (1, AveFunctionalClassification.NORMAL),
+        (-1, AveFunctionalClassification.ABNORMAL),
     ],
 )
-def test_functional_classification_of_variant_with_ranges(
-    client, session, data_provider, data_files, setup_lib_db, file_path, expected_classification
-):
-    experiment = create_experiment(client)
-    score_set = create_seq_score_set_with_mapped_variants(
-        client,
-        session,
-        data_provider,
-        experiment["urn"],
-        data_files / file_path,
-        update={"scoreRanges": camelize(TEST_SCORE_SET_RANGE)},
-    )
+def test_functional_classification_of_variant_with_ranges(mock_mapped_variant, score, expected_classification):
+    mock_mapped_variant.variant.data["score_data"]["score"] = score
 
-    mapped_variant = session.scalar(
-        select(MappedVariantDbModel)
-        .join(VariantDbModel)
-        .join(ScoreSetDbModel)
-        .filter(ScoreSetDbModel.urn == score_set["urn"])
-    )
-    assert mapped_variant
-
-    result = functional_classification_of_variant(mapped_variant)
+    result = functional_classification_of_variant(mock_mapped_variant)
     assert result == expected_classification
 
 
-def test_functional_classification_of_variant_without_ranges(client, session, data_provider, data_files, setup_lib_db):
-    experiment = create_experiment(client)
-    score_set = create_seq_score_set_with_mapped_variants(
-        client,
-        session,
-        data_provider,
-        experiment["urn"],
-        data_files / "scores_normal.csv",
-    )
-
-    mapped_variant = session.scalar(
-        select(MappedVariantDbModel)
-        .join(VariantDbModel)
-        .join(ScoreSetDbModel)
-        .filter(ScoreSetDbModel.urn == score_set["urn"])
-    )
-    assert mapped_variant
+def test_functional_classification_of_variant_without_ranges(mock_mapped_variant):
+    mock_mapped_variant.variant.score_set.score_ranges = None
 
-    result = functional_classification_of_variant(mapped_variant)
+    result = functional_classification_of_variant(mock_mapped_variant)
     assert result is None
 
 
 @pytest.mark.parametrize(
-    "file_path,expected_classification",
+    "score,expected_classification",
     [
-        ("scores_no_evidence.csv", None),
-        ("scores_b53_supporting.csv", AveClinicalClassification.BS3_SUPPORTING),
-        ("scores_p53_supporting.csv", AveClinicalClassification.PS3_SUPPORTING),
-        ("scores_b53_moderate.csv", AveClinicalClassification.BS3_MODERATE),
-        ("scores_p53_moderate.csv", AveClinicalClassification.PS3_MODERATE),
-        ("scores_b53_strong.csv", AveClinicalClassification.BS3_STRONG),
-        ("scores_p53_strong.csv", AveClinicalClassification.PS3_STRONG),
-        ("scores_b53_very_strong.csv", AveClinicalClassification.BS3_STRONG),
-        ("scores_p53_very_strong.csv", AveClinicalClassification.PS3_STRONG),
+        (0, None),
+        (-1, AveClinicalClassification.BS3_SUPPORTING),
+        (1, AveClinicalClassification.PS3_SUPPORTING),
+        (-2, AveClinicalClassification.BS3_MODERATE),
+        (2, AveClinicalClassification.PS3_MODERATE),
+        (-4, AveClinicalClassification.BS3_STRONG),
+        (4, AveClinicalClassification.PS3_STRONG),
+        (-8, AveClinicalClassification.BS3_STRONG),
+        (8, AveClinicalClassification.PS3_STRONG),
     ],
 )
-def test_clinical_classification_of_variant_with_thresholds(
-    client, session, data_provider, data_files, setup_lib_db, admin_app_overrides, file_path, expected_classification
-):
-    experiment = create_experiment(client)
-    score_set = create_seq_score_set_with_mapped_variants(
-        client,
-        session,
-        data_provider,
-        experiment["urn"],
-        data_files / file_path,
-    )
+def test_clinical_classification_of_variant_with_thresholds(score, mock_mapped_variant, expected_classification):
+    mock_mapped_variant.variant.data["score_data"]["score"] = score
 
-    with DependencyOverrider(admin_app_overrides):
-        add_thresholds_to_score_set(client, score_set["urn"], TEST_SCORE_CALIBRATION)
-
-    mapped_variant = session.scalar(
-        select(MappedVariantDbModel)
-        .join(VariantDbModel)
-        .join(ScoreSetDbModel)
-        .filter(ScoreSetDbModel.urn == score_set["urn"])
-    )
-    assert mapped_variant
-
-    result = pillar_project_clinical_classification_of_variant(mapped_variant)
+    result = pillar_project_clinical_classification_of_variant(mock_mapped_variant)
     assert result == expected_classification
 
 
-def test_clinical_classification_of_variant_without_thresholds(
-    client, session, data_provider, data_files, setup_lib_db
-):
-    experiment = create_experiment(client)
-    score_set = create_seq_score_set_with_mapped_variants(
-        client,
-        session,
-        data_provider,
-        experiment["urn"],
-        data_files / "scores_p53_supporting.csv",
-    )
-
-    mapped_variant = session.scalar(
-        select(MappedVariantDbModel)
-        .join(VariantDbModel)
-        .join(ScoreSetDbModel)
-        .filter(ScoreSetDbModel.urn == score_set["urn"])
-    )
-    assert mapped_variant
+def test_clinical_classification_of_variant_without_thresholds(mock_mapped_variant):
+    mock_mapped_variant.variant.score_set.score_calibrations = None
 
-    result = pillar_project_clinical_classification_of_variant(mapped_variant)
+    result = pillar_project_clinical_classification_of_variant(mock_mapped_variant)
     assert result is None