loqusdb 2.7.2__py3-none-any.whl → 2.7.8__py3-none-any.whl

tests/build_models/test_build_case.py

@@ -0,0 +1,150 @@
+import pytest
+
+from loqusdb.build_models.case import build_case, get_individual_positions
+from loqusdb.exceptions import CaseError
+
+
+def test_get_individual_positions():
+    ## GIVEN a list with ids
+    inds = ["1", "2", "3"]
+    ## WHEN getting the individual positions
+    ind_pos = get_individual_positions(inds)
+    ## THEN assert they where given the correct position
+    assert ind_pos["1"] == 0
+    assert ind_pos["2"] == 1
+    assert ind_pos["3"] == 2
+
+
+def test_get_individual_positions_no_inds():
+    ## GIVEN a list with ids
+    inds = None
+    ## WHEN getting the individual positions
+    ind_pos = get_individual_positions(inds)
+    ## THEN assert an empty dict is returned
+    assert ind_pos == {}
+
+
+def test_build_case_no_ped():
+    ## GIVEN some vcf individuals
+
+    vcf_individuals = ["mother", "proband"]
+    case_id = "test"
+
+    ## WHEN building a case object
+    case_obj = build_case(
+        case=None,
+        vcf_individuals=vcf_individuals,
+        case_id=case_id,
+    )
+
+    ## THEN assert that the case got the right ID
+    assert case_obj["case_id"] == case_id
+    for ind_obj in case_obj["individuals"]:
+        assert ind_obj["name"] in vcf_individuals
+        assert ind_obj["ind_id"] in vcf_individuals
+
+
+def test_build_case_no_ped_no_case_id():
+    ## WHEN building a case object
+
+    ## THEN assert a CaseError is raised
+    with pytest.raises(CaseError):
+        ## GIVEN some vcf individuals
+
+        vcf_individuals = ["mother", "proband"]
+
+        case_obj = build_case(
+            case=None,
+            vcf_individuals=vcf_individuals,
+        )
+
+
+def test_build_case_ped(family_obj, vcf_path):
+    ## GIVEN a ped parser family_obj
+    vcf_inds = [ind_id for ind_id in family_obj.individuals]
+    nr_variants = 10
+
+    ## WHEN building a case object
+    case_obj = build_case(
+        case=family_obj,
+        vcf_individuals=vcf_inds,
+        vcf_path=vcf_path,
+        nr_variants=nr_variants,
+    )
+
+    ## THEN assert that the case has the correct id
+    assert case_obj["case_id"] == family_obj.family_id
+
+    for ind_obj in case_obj["individuals"]:
+        assert ind_obj["ind_id"] in vcf_inds
+
+    ## THEN assert that the vcf_path was added
+    assert case_obj["vcf_path"] == vcf_path
+
+    ## THEN assert that the nr variants is correct
+    assert case_obj["nr_variants"] == nr_variants
+
+
+def test_build_case_ped_sv(family_obj, sv_vcf_path):
+    ## GIVEN a ped parser family_obj
+    vcf_inds = [ind_id for ind_id in family_obj.individuals]
+    nr_sv_variants = 10
+
+    ## WHEN building a case object
+    case_obj = build_case(
+        case=family_obj,
+        sv_individuals=vcf_inds,
+        vcf_sv_path=sv_vcf_path,
+        nr_sv_variants=nr_sv_variants,
+    )
+
+    ## THEN assert that the case has the correct id
+    assert case_obj["case_id"] == family_obj.family_id
+
+    case_obj["individuals"] == []
+    for ind_obj in case_obj["sv_individuals"]:
+        assert ind_obj["ind_id"] in vcf_inds
+
+    ## THEN assert that the vcf_path was added
+    assert case_obj["vcf_path"] is None
+    assert case_obj["vcf_sv_path"] == sv_vcf_path
+
+    ## THEN assert that the nr variants is correct
+    assert case_obj["nr_variants"] is None
+    assert case_obj["nr_sv_variants"] == nr_sv_variants
+
+
+def test_build_case_ped_sv_and_snv(family_obj, sv_vcf_path, vcf_path):
+    ## GIVEN a ped parser family_obj
+    vcf_inds = [ind_id for ind_id in family_obj.individuals]
+    sv_vcf_inds = [ind_id for ind_id in family_obj.individuals]
+    nr_sv_variants = 10
+    nr_variants = 20
+
+    ## WHEN building a case object
+    case_obj = build_case(
+        case=family_obj,
+        sv_individuals=vcf_inds,
+        vcf_sv_path=sv_vcf_path,
+        nr_sv_variants=nr_sv_variants,
+        vcf_individuals=vcf_inds,
+        vcf_path=vcf_path,
+        nr_variants=nr_variants,
+    )
+
+    ## THEN assert that the case has the correct id
+    assert case_obj["case_id"] == family_obj.family_id
+
+    for ind_obj in case_obj["individuals"]:
+        assert ind_obj["ind_id"] in vcf_inds
+
+    for ind_obj in case_obj["sv_individuals"]:
+        assert ind_obj["ind_id"] in sv_vcf_inds
+
+    ## THEN assert that the vcf_path was added
+    assert case_obj["vcf_path"] == vcf_path
+    assert case_obj["vcf_sv_path"] == sv_vcf_path
+
+    ## THEN assert that the nr variants is correct
+    assert case_obj["nr_variants"] == nr_variants
+    assert case_obj["nr_sv_variants"] == nr_sv_variants

tests/build_models/test_build_variant.py

@@ -0,0 +1,15 @@
+from loqusdb.build_models.variant import get_coords, build_variant
+
+
+def test_build_het_variant(het_variant, case_obj):
+    variant_obj = build_variant(variant=het_variant, case_obj=case_obj)
+    assert variant_obj["chrom"] == het_variant.CHROM
+    assert variant_obj["homozygote"] == 0
+    assert variant_obj["hemizygote"] == 0
+
+
+def test_get_coords_for_BND(bnd_variant):
+    coords = get_coords(bnd_variant)
+    assert coords["pos"] == coords["end"]
+    assert coords["sv_length"] == float("inf")
+    assert coords["sv_type"] == "BND"

tests/build_models/test_is_greater.py

@@ -0,0 +1,49 @@
+from loqusdb.build_models.variant import Position, is_greater
+
+
+def test_is_greater_different_chrom():
+    ## GIVEN two positions where a is smaller than b. Different chroms
+    a = Position("1", 100)
+    b = Position("3", 100)
+
+    ## WHEN testing if a is greater than b
+    res = is_greater(a, b)
+    ## THEN assert a was not greater than b
+    assert res is False
+
+    ## WHEN testing if b is greater than a
+    res = is_greater(b, a)
+    ## THEN assert b was greater than a
+    assert res is True
+
+
+def test_is_greater_same_chrom():
+    ## GIVEN two positions where a is smaller than b. Same chroms
+    a = Position("1", 100)
+    b = Position("1", 300)
+
+    ## WHEN testing if a is greater than b
+    res = is_greater(a, b)
+    ## THEN assert a was not greater than b
+    assert res is False
+
+    ## WHEN testing if b is greater than a
+    res = is_greater(b, a)
+    ## THEN assert b was greater than a
+    assert res is True
+
+
+def test_is_greater_wierd_chrom():
+    ## GIVEN two positions where one chrom is unknown b
+    a = Position("1", 100)
+    b = Position("GRLrs2", 300)
+
+    ## WHEN testing if a is greater than b
+    res = is_greater(a, b)
+    ## THEN assert a was not greater than b
+    assert res is False
+
+    ## WHEN testing if b is greater than a
+    res = is_greater(b, a)
+    ## THEN assert a was not greater than b
+    assert res is False

tests/commands/test_export.py

@@ -0,0 +1,16 @@
+from click.testing import CliRunner
+
+from loqusdb.commands.cli import cli as base_command
+
+def test_export_base(real_db_name:str):
+    """Test the base command that exports variants."""
+
+    runner = CliRunner()
+
+    # WHEN the base command to export cases is run
+    command = ["--database", real_db_name, "export"]
+
+    ## THEN it should return success
+    result = runner.invoke(base_command, command)
+    assert result.exit_code == 0
+

tests/commands/test_identity.py

@@ -0,0 +1,22 @@
+from click.testing import CliRunner
+
+from loqusdb.commands.cli import cli as base_command
+
+def test_identity(real_db_name:str):
+    """Test the SV identity base command."""
+
+    runner = CliRunner()
+
+    # WHEN the base identity command is run on an empty database
+    command = ["--database", real_db_name, "identity", "-v", "1_7890024_TGA_GGG"]
+
+    # THEN the command should return success
+    result = runner.invoke(base_command, command)
+    assert result.exit_code == 0
+
+    # AND no variant found message
+    assert "No hits for variant" in result.output
+
+
+
+

tests/commands/test_view.py

@@ -0,0 +1,17 @@
+from click.testing import CliRunner
+from loqusdb.plugins.mongo.adapter import MongoAdapter
+from loqusdb.commands.cli import cli as base_command
+
+def test_view_cases_base(real_mongo_adapter: MongoAdapter, real_db_name:str):
+    """Test the base command that returns database cases."""
+
+    ## GIVEN an empty database
+    assert sum([1 for _ in real_mongo_adapter.cases()]) == 0
+
+    runner = CliRunner()
+
+    # THEN the case command should return No cases found error
+    command = ["--database", real_db_name, "cases" ]
+    result = runner.invoke(base_command, command)
+    assert result.exit_code == 1
+    assert "No cases found in database" in result.output

tests/conftest.py

@@ -0,0 +1,438 @@
+import logging
+
+import cyvcf2
+import pytest
+
+from loqusdb.build_models.case import build_case
+from loqusdb.build_models.variant import build_variant
+from loqusdb.log import init_log
+from loqusdb.models import Case
+from loqusdb.plugins.mongo.adapter import MongoAdapter
+from loqusdb.utils.load import update_case
+from mongomock import MongoClient as MockClient
+from ped_parser import FamilyParser
+from pymongo import MongoClient
+
+logger = logging.getLogger(".")
+
+init_log(logger, loglevel="DEBUG")
+
+REAL_DATABASE = "loqus-test"
+TEST_DATABASE = "test"
+
+
+class CyvcfVariant(object):
+    """Mock a cyvcf variant
+
+    Default is to return a variant with three individuals high genotype
+    quality.
+    """
+
+    def __init__(
+        self,
+        chrom="1",
+        pos=80000,
+        ref="A",
+        alt="C",
+        end=None,
+        gt_quals=[60, 60, 60],
+        gt_types=[1, 1, 0],
+        var_type="snv",
+        var_id=None,
+        info_dict={},
+    ):
+        super(CyvcfVariant, self).__init__()
+        self.CHROM = chrom
+        self.POS = pos
+        self.REF = ref
+        self.ALT = [alt]
+        self.end = end or pos
+        self.gt_quals = gt_quals
+        self.gt_types = gt_types
+        self.var_type = var_type
+        self.INFO = info_dict
+        if var_id is None:
+            var_id = "."
+        self.ID = var_id
+
+
+@pytest.fixture(scope="function")
+def real_db_name(request):
+    """Return the name of the real mongo test db"""
+    return REAL_DATABASE
+
+
+@pytest.fixture(scope="function")
+def mongo_client(request):
+    """Return a mongomock client"""
+    client = MockClient(directConnection=True)
+    return client
+
+
+@pytest.fixture(scope="function")
+def real_mongo_client(request):
+    """Return a mongomock client"""
+    client = MongoClient(directConnection=True)
+
+    def teardown():
+        print("\n")
+        logger.info("Deleting database")
+        client.drop_database(REAL_DATABASE)
+        logger.info("Database deleted")
+
+    request.addfinalizer(teardown)
+
+    return client
+
+
+@pytest.fixture(scope="function")
+def mongo_adapter(request, mongo_client):
+    """Return a mongo adapter"""
+    db_name = TEST_DATABASE
+    adapter = MongoAdapter(mongo_client, db_name)
+
+    return adapter
+
+
+@pytest.fixture(scope="function")
+def real_mongo_adapter(request, real_mongo_client):
+    """Return a mongo adapter"""
+    db_name = REAL_DATABASE
+    adapter = MongoAdapter(real_mongo_client, db_name)
+
+    return adapter
+
+
+@pytest.fixture(scope="function")
+def simplest_variant(request):
+    variant = {
+        "_id": "test",
+    }
+    return variant
+
+
+@pytest.fixture(scope="function")
+def homozygous_variant(request):
+    variant = {"_id": "test", "homozygote": 1, "case_id": "1"}
+    return variant
+
+
+@pytest.fixture(scope="function")
+def simple_case(request):
+    case = Case("test", "./test.vcf")
+
+    return case
+
+
+@pytest.fixture(scope="function")
+def vcf_path(request):
+    file_path = "tests/fixtures/test.vcf"
+    return file_path
+
+
+@pytest.fixture(scope="function")
+def sv_vcf_path(request):
+    file_path = "tests/fixtures/test.SV.vcf"
+    return file_path
+
+
+@pytest.fixture(scope="function")
+def double_vcf_path(request):
+    "This will return a vcf with the same variant two times"
+    file_path = "tests/fixtures/double_variant.vcf"
+    return file_path
+
+
+@pytest.fixture(scope="function")
+def unsorted_vcf_path(request):
+    "This will return a vcf with unsorted variants"
+    file_path = "tests/fixtures/unsorted.vcf"
+    return file_path
+
+
+@pytest.fixture(scope="function")
+def zipped_vcf_path(request):
+    "Returns a VCF that is gzipped and have a index companion"
+    file_path = "tests/fixtures/test.vcf.gz"
+    return file_path
+
+
+@pytest.fixture(scope="function")
+def profile_vcf_path(request):
+    "Returns a VCF containing profile variants"
+    file_path = "tests/fixtures/profile_snv.vcf"
+    return file_path
+
+
+@pytest.fixture(scope="function")
+def ped_path(request):
+    file_path = "tests/fixtures/recessive_trio.ped"
+    return file_path
+
+
+@pytest.fixture(scope="function")
+def funny_ped_path(request):
+    "Returns a ped file with incorrect family relations"
+    return "tests/fixtures/funny_trio.ped"
+
+
+@pytest.fixture(scope="function")
+def ind_positions(request):
+    return {"proband": 0, "mother": 1, "father": 2}
+
+
+@pytest.fixture(scope="function")
+def case_lines(request, ped_path):
+    """Return ped formated case lines"""
+    case = []
+    with open(ped_path, "r") as f:
+        for line in f:
+            case.append(line)
+
+    return case
+
+
+@pytest.fixture(scope="function")
+def case_id(request, ped_path):
+    """Return ped formated case lines"""
+    case_id = None
+    with open(ped_path, "r") as f:
+        for line in f:
+            case_id = line.split("\t")[0]
+
+    return case_id
+
+
+@pytest.fixture(scope="function")
+def vcf_obj(request, vcf_path):
+    """return a cyvcf2.VCF obj"""
+    return cyvcf2.VCF(vcf_path)
+
+
+@pytest.fixture(scope="function")
+def sv_vcf_obj(request, sv_vcf_path):
+    """return a cyvcf2.VCF obj"""
+    return cyvcf2.VCF(sv_vcf_path)
+
+
+@pytest.fixture(scope="function")
+def profile_list(request):
+    return ["AA", "CC", "GG", "TT"]
+
+
+@pytest.fixture(scope="function")
+def case_obj(request, case_lines, vcf_obj, vcf_path, profile_list):
+    """Return a case obj"""
+    family_parser = FamilyParser(case_lines, family_type="ped")
+    families = list(family_parser.families.keys())
+    family = family_parser.families[families[0]]
+    vcf_individuals = vcf_obj.samples
+    nr_variants = 0
+    for nr_variants, variant in enumerate(vcf_obj, 1):
+        continue
+    return build_case(
+        case=family,
+        vcf_individuals=vcf_individuals,
+        vcf_path=vcf_path,
+        nr_variants=nr_variants,
+        profiles={individual: profile_list for individual in vcf_individuals},
+    )
+
+
+@pytest.fixture(scope="function")
+def sv_case_obj(request, case_lines, sv_vcf_obj, sv_vcf_path):
+    """Return a case obj"""
+    family_parser = FamilyParser(case_lines, family_type="ped")
+    families = list(family_parser.families.keys())
+    family = family_parser.families[families[0]]
+    vcf_individuals = sv_vcf_obj.samples
+    nr_variants = 0
+    for nr_variants, variant in enumerate(sv_vcf_obj, 1):
+        continue
+    return build_case(
+        case=family,
+        sv_individuals=vcf_individuals,
+        vcf_sv_path=sv_vcf_path,
+        nr_sv_variants=nr_variants,
+    )
+
+
+@pytest.fixture(scope="function")
+def complete_case_obj(request, case_obj, sv_case_obj):
+    """Return a case obj with both sv and snv information"""
+    return update_case(case_obj, sv_case_obj)
+
+
+@pytest.fixture(scope="function")
+def family_obj(request, case_lines):
+    """Return a case obj"""
+    family_parser = FamilyParser(case_lines, family_type="ped")
+    families = list(family_parser.families.keys())
+    return family_parser.families[families[0]]
+
+
+@pytest.fixture(scope="function")
+def case_id(request, case_lines):
+    """Return a case id"""
+    family_parser = FamilyParser(case_lines, family_type="ped")
+    families = list(family_parser.families.keys())
+    family = family_parser.families[families[0]]
+    return family.family_id
+
+
+@pytest.fixture(scope="function")
+def individuals(request, case_obj):
+    """Return a case obj"""
+
+    return case_obj.individuals
+
+
+@pytest.fixture(scope="function")
+def two_cases(request):
+    """Return ped formated case lines"""
+    return [
+        "#FamilyID\tSampleID\tFather\tMother\tSex\tPhenotype\n",
+        "1\tproband\t0\t0\t1\t2\n",
+        "2\tproband\t0\t0\t2\t1\n",
+    ]
+
+
+## Variant fixtures:
+
+# chrom='1',
+# pos=80000,
+# ref='A',
+# alt='C',
+# end=None,
+# gt_quals=[60, 60, 60],
+# gt_types=[1, 1, 0],
+# var_type='snv',
+# info_dict={}
+
+### Variant objects
+
+
+@pytest.fixture(scope="function")
+def variant_obj(request, het_variant, ind_positions, individuals):
+    return build_variant(
+        variant=het_variant,
+        individuals=individuals,
+        ind_positions=ind_positions,
+        case_id="test",
+        gq_threshold=None,
+    )
+
+
+### CYVCF2 variants
+### SNVs:
+@pytest.fixture(scope="function")
+def hem_variant(request):
+    return CyvcfVariant(chrom="X", pos=60000)
+
+
+@pytest.fixture(scope="function")
+def variant_chr(request):
+    return CyvcfVariant(chrom="chrX", pos=60000)
+
+
+@pytest.fixture(scope="function")
+def par_variant(request):
+    return CyvcfVariant(chrom="X", pos=60001)
+
+
+@pytest.fixture(scope="function")
+def het_variant(request):
+    return CyvcfVariant()
+
+
+@pytest.fixture(scope="function")
+def bnd_variant(request):
+    return CyvcfVariant(
+        chrom="1",
+        pos=80000,
+        alt="N[1:80000[",
+        ref="N",
+        end=80000,
+        info_dict={"SVTYPE": "BND"},
+    )
+
+
+@pytest.fixture(scope="function")
+def variant_no_gq(request):
+    return CyvcfVariant(gt_quals=[-1, -1, -1])
+
+
+@pytest.fixture(scope="function")
+def hom_variant(request):
+    return CyvcfVariant(gt_types=[3, 1, 1])
+
+
+@pytest.fixture(scope="function")
+def variant_no_call(request):
+    return CyvcfVariant(gt_types=[2, 2, 2])
+
+
+### SVs:
+@pytest.fixture(scope="function")
+def del_variant(request):
+    return CyvcfVariant(
+        chrom="1",
+        ref="G",
+        alt="<DEL>",
+        pos=1285001,
+        end=1287000,
+        var_type="sv",
+        info_dict={"END": 1287000, "SVLEN": -20000, "SVTYPE": "DEL"},
+    )
+
+
+@pytest.fixture(scope="function")
+def small_insert_variant(request):
+    return CyvcfVariant(
+        chrom="1",
+        ref="G",
+        alt="GGGACGGGGGTTCTGAGATAAGCAAGCCCCCACCAGGTGAGACCGGCGGAGCTGTGGCCACCGAGGTCCCGGGAGCTGGTGCT",
+        pos=3021145,
+        end=3021145,
+        var_type="sv",
+        info_dict={"END": 3021145, "SVLEN": 82, "SVTYPE": "INS"},
+    )
+
+
+@pytest.fixture(scope="function")
+def insertion_variant(request):
+    return CyvcfVariant(
+        chrom="1",
+        ref="A",
+        alt="<INS>",
+        pos=3177306,
+        end=3177306,
+        var_type="sv",
+        info_dict={"END": 3177306, "SVLEN": None, "SVTYPE": "INS"},
+    )
+
+
+@pytest.fixture(scope="function")
+def duptandem_variant(request):
+    return CyvcfVariant(
+        chrom="1",
+        ref="A",
+        alt="<DUP:TANDEM>",
+        pos=3092626,
+        end=3092849,
+        var_type="sv",
+        info_dict={"END": 3092849, "SVLEN": 223, "SVTYPE": "DUP"},
+    )
+
+
+@pytest.fixture(scope="function")
+def translocation_variant(request):
+    return CyvcfVariant(
+        chrom="1",
+        ref="N",
+        alt="N[11:119123896[",
+        pos=3754913,
+        end=3754913,
+        var_type="sv",
+        info_dict={"END": None, "SVLEN": None, "SVTYPE": "BND"},
+    )