diff options
Diffstat (limited to 'wqflask/tests')
53 files changed, 0 insertions, 3802 deletions
diff --git a/wqflask/tests/__init__.py b/wqflask/tests/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/__init__.py +++ /dev/null diff --git a/wqflask/tests/integration/__init__.py b/wqflask/tests/integration/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/integration/__init__.py +++ /dev/null diff --git a/wqflask/tests/integration/wqflask/__init__.py b/wqflask/tests/integration/wqflask/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/integration/wqflask/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/__init__.py b/wqflask/tests/unit/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/base/__init__.py b/wqflask/tests/unit/base/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/base/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/base/test_data_set.py b/wqflask/tests/unit/base/test_data_set.py deleted file mode 100644 index 744c8a94..00000000 --- a/wqflask/tests/unit/base/test_data_set.py +++ /dev/null @@ -1,238 +0,0 @@ -"""Tests for wqflask/base/data_set.py""" - -import unittest -from unittest import mock -from dataclasses import dataclass -from gn3.monads import MonadicDict - -from wqflask import app -from base.data_set import DatasetType -from base.data_set.dataset import DataSet - -GEN_MENU_JSON = """ -{ - "datasets": { - "human": { - "HLC": { - "Liver mRNA": [ - [ - "320", - "HLC_0311", - "GSE9588 Human Liver Normal (Mar11) Both Sexes" - ] - ], - "Phenotypes": [ - [ - "635", - "HLCPublish", - "HLC Published Phenotypes" - ] - ] - } - }, - "mouse": { - "BXD": { - "Genotypes": [ - [ - "600", - "BXDGeno", - "BXD Genotypes" - ] - ], - "Hippocampus mRNA": [ - [ - "112", - "HC_M2_0606_P", - "Hippocampus Consortium M430v2 (Jun06) PDNN" - ] - ], - "Phenotypes": [ - [ - "602", - "BXDPublish", - "BXD Published Phenotypes" - ] - ] - } - } - }, - "groups": { - "human": [ - [ - "HLC", - "Liver: Normal Gene Expression with Genotypes (Merck)", - "Family:None" - ] - ], - "mouse": [ - [ - "BXD", - "BXD", - "Family:None" - ] - ] - }, - "species": [ - [ - "human", - "Human" - ], - [ - "mouse", - "Mouse" - ] - ], - "types": { - "human": { - "HLC": [ - [ - "Phenotypes", - "Traits and Cofactors", - "Phenotypes" - ], - [ - "Liver mRNA", - "Liver mRNA", - "Molecular Trait Datasets" - ] - ] - }, - "mouse": { - "BXD": [ - [ - "Phenotypes", - "Traits and Cofactors", - "Phenotypes" - ], - [ - "Genotypes", - "DNA Markers and SNPs", - "Genotypes" - ], - [ - "Hippocampus mRNA", - "Hippocampus mRNA", - "Molecular Trait Datasets" - ] - ] - } - } -} -""" - -class MockPhenotypeDataset(DataSet): - def setup(self): - self.type = "Publish" - self.query_for_group = "" - self.group = "" - - - def check_confidentiality(self): - pass - - def retrieve_other_names(self): - pass - -@dataclass -class MockGroup: - name = "Group" - -class TestDataSetTypes(unittest.TestCase): - """Tests for the DataSetType class""" - - def setUp(self): - self.test_dataset = """ - { - "AD-cases-controls-MyersGeno": "Geno", - "AD-cases-controls-MyersPublish": "Publish", - "AKXDGeno": "Geno", - "AXBXAGeno": "Geno", - "AXBXAPublish": "Publish", - "Aging-Brain-UCIPublish": "Publish", - "All Phenotypes": "Publish", - "B139_K_1206_M": "ProbeSet", - "B139_K_1206_R": "ProbeSet" - } - """ - self.app_context = app.app_context() - self.app_context.push() - - def tearDown(self): - self.app_context.pop() - - def test_data_set_type(self): - """Test that DatasetType returns correctly if the Redis Instance is not empty - and the name variable exists in the dictionary - - """ - with app.app_context(): - redis_mock = mock.Mock() - cursor_mock = mock.Mock() - redis_mock.get.return_value = self.test_dataset - self.assertEqual(DatasetType(redis_mock) - ("All Phenotypes", redis_mock, cursor_mock), "Publish") - redis_mock.get.assert_called_once_with("dataset_structure") - - @mock.patch('base.data_set.datasettype.requests.get') - def test_data_set_type_with_empty_redis(self, request_mock): - """Test that DatasetType returns correctly if the Redis Instance is empty and - the name variable exists in the dictionary - - """ - with app.app_context(): - request_mock.return_value.content = GEN_MENU_JSON - redis_mock = mock.Mock() - cursor_mock = mock.Mock() - redis_mock.get.return_value = None - data_set = DatasetType(redis_mock) - self.assertEqual(data_set("BXDGeno", redis_mock, cursor_mock), - "Geno") - self.assertEqual(data_set("BXDPublish", redis_mock, cursor_mock), - "Publish") - self.assertEqual(data_set("HLC_0311", redis_mock, cursor_mock), - "ProbeSet") - - redis_mock.set.assert_called_once_with( - "dataset_structure", - ('{"HLC_0311": "ProbeSet", ' - '"HLCPublish": "Publish", ' - '"BXDGeno": "Geno", ' - '"HC_M2_0606_P": "ProbeSet", ' - '"BXDPublish": "Publish"}')) - - -class TestDatasetAccessionId(unittest.TestCase): - """Tests for the DataSetType class""" - - @mock.patch("base.data_set.dataset.query_sql") - @mock.patch("base.data_set.dataset.DatasetGroup") - def test_get_accession_id(self, mock_dataset_group, mock_query_sql): - def mock_fn(): - yield MonadicDict({"accession_id": 7}) - mock_dataset_group.return_value = MockGroup() - mock_query_sql.return_value = mock_fn() - sample_dataset = MockPhenotypeDataset( - name="BXD-LongevityPublish", - get_samplelist=False, - group_name="BXD", - redis_conn=mock.Mock() - ) - sample_dataset\ - .accession_id\ - .bind(lambda x: self.assertEqual(7, x)) - - @mock.patch("base.data_set.dataset.query_sql") - @mock.patch("base.data_set.dataset.DatasetGroup") - def test_get_accession_id_empty_return(self, mock_dataset_group, - mock_query_sql): - mock_dataset_group.return_value = MockGroup() - mock_query_sql.return_value = None - sample_dataset = MockPhenotypeDataset( - name="BXD-LongevityPublish", - get_samplelist=False, - group_name="BXD", - redis_conn=mock.Mock() - ) - sample_dataset\ - .accession_id\ - .bind(lambda x: self.assertNone(x)) diff --git a/wqflask/tests/unit/base/test_general_object.py b/wqflask/tests/unit/base/test_general_object.py deleted file mode 100644 index 00fd3c72..00000000 --- a/wqflask/tests/unit/base/test_general_object.py +++ /dev/null @@ -1,40 +0,0 @@ -import unittest - -from base.GeneralObject import GeneralObject - - -class TestGeneralObjectTests(unittest.TestCase): - """ - Test the GeneralObject base class - """ - - def test_object_contents(self): - """Test whether base contents are stored properly""" - test_obj = GeneralObject("a", "b", "c") - self.assertEqual("abc", ''.join(test_obj.contents)) - self.assertEqual(len(test_obj), 0) - - def test_object_dict(self): - """Test whether the base class is printed properly""" - test_obj = GeneralObject("a", name="test", value=1) - self.assertEqual(str(test_obj), "name = test\nvalue = 1\n") - self.assertEqual( - repr(test_obj), "contents = ['a']\nname = test\nvalue = 1\n") - self.assertEqual(len(test_obj), 2) - self.assertEqual(test_obj["value"], 1) - test_obj["test"] = 1 - self.assertEqual(test_obj["test"], 1) - - def test_get_attribute(self): - "Test that getattr works" - test_obj = GeneralObject("a", name="test", value=1) - self.assertEqual(getattr(test_obj, "value", None), 1) - self.assertEqual(getattr(test_obj, "non-existent", None), None) - - def test_object_comparisons(self): - "Test that 2 objects of the same length are equal" - test_obj1 = GeneralObject("a", name="test", value=1) - test_obj2 = GeneralObject("b", name="test2", value=2) - test_obj3 = GeneralObject("a", name="test", x=1, y=2) - self.assertTrue(test_obj1 == test_obj2) - self.assertFalse(test_obj1 == test_obj3) diff --git a/wqflask/tests/unit/base/test_mrna_assay_tissue_data.py b/wqflask/tests/unit/base/test_mrna_assay_tissue_data.py deleted file mode 100644 index c43fb4b6..00000000 --- a/wqflask/tests/unit/base/test_mrna_assay_tissue_data.py +++ /dev/null @@ -1,81 +0,0 @@ -import pytest -from base.mrna_assay_tissue_data import MrnaAssayTissueData - - -@pytest.mark.parametrize( - ('gene_symbols', 'expected_query', 'sql_fetch_all_results'), - ( - (None, - (("SELECT t.Symbol, t.GeneId, t.DataId, " - "t.Chr, t.Mb, t.description, " - "t.Probe_Target_Description " - "FROM (SELECT Symbol, " - "max(Mean) AS maxmean " - "FROM TissueProbeSetXRef WHERE " - "TissueProbeSetFreezeId=1 AND " - "Symbol != '' AND Symbol IS NOT " - "Null GROUP BY Symbol) " - "AS x INNER JOIN TissueProbeSetXRef " - "AS t ON t.Symbol = x.Symbol " - "AND t.Mean = x.maxmean"),), - (("symbol", "gene_id", - "data_id", "chr", "mb", - "description", - "probe_target_description"),)), - (["k1", "k2", "k3"], - ("SELECT t.Symbol, t.GeneId, t.DataId, " - "t.Chr, t.Mb, t.description, " - "t.Probe_Target_Description FROM (SELECT Symbol, " - "max(Mean) AS maxmean " - "FROM TissueProbeSetXRef WHERE " - "TissueProbeSetFreezeId=1 AND " - "Symbol IN (%s, %s, %s) " - "GROUP BY Symbol) AS x INNER JOIN " - "TissueProbeSetXRef AS " - "t ON t.Symbol = x.Symbol " - "AND t.Mean = x.maxmean", - ("k1", "k2", "k3")), - (("k1", "203", - "112", "xy", "20.11", - "Sample Description", - "Sample Probe Target Description"),)), - ), -) -def test_mrna_assay_tissue_data_initialisation(mocker, gene_symbols, - expected_query, - sql_fetch_all_results): - mock_conn = mocker.MagicMock() - with mock_conn.cursor() as cursor: - cursor.fetchall.return_value = sql_fetch_all_results - MrnaAssayTissueData(conn=mock_conn, gene_symbols=gene_symbols) - cursor.execute.assert_called_with(*expected_query) - - -def test_get_trait_symbol_and_tissue_values(mocker): - """Test for getting trait symbol and tissue_values""" - mock_conn = mocker.MagicMock() - with mock_conn.cursor() as cursor: - cursor.fetchall.side_effect = [ - (("k1", "203", - "112", "xy", "20.11", - "Sample Description", - "Sample Probe Target Description"),), - (("k1", "v1"), - ("k2", "v2"), - ("k3", "v3")), - ] - _m = MrnaAssayTissueData(conn=mock_conn, - gene_symbols=["k1", "k2", "k3"]) - assert _m.get_symbol_values_pairs() == { - "k1": ["v1"], - "k2": ["v2"], - "k3": ["v3"], - } - cursor.execute.assert_called_with( - "SELECT TissueProbeSetXRef.Symbol, " - "TissueProbeSetData.value FROM " - "TissueProbeSetXRef, TissueProbeSetData " - "WHERE TissueProbeSetData.Id IN (%s) " - "AND TissueProbeSetXRef.DataId = " - "TissueProbeSetData.Id", - ('112',)) diff --git a/wqflask/tests/unit/base/test_species.py b/wqflask/tests/unit/base/test_species.py deleted file mode 100644 index f12bde6d..00000000 --- a/wqflask/tests/unit/base/test_species.py +++ /dev/null @@ -1,80 +0,0 @@ -"""Tests wqflask/base/species.py""" -import pytest -from base.species import TheSpecies -from base.species import IndChromosome -from base.species import Chromosomes -from collections import OrderedDict -from dataclasses import dataclass - - -@dataclass -class MockChromosome: - OrderId: int - Name: str - Length: int - - -@dataclass -class MockGroup: - name: str - - -@dataclass -class MockDataset: - group: MockGroup - - -@pytest.mark.parametrize( - ("species_name", "dataset", "expected_name", "chromosome_param"), - (("BXD", None, "BXD", 1), - (None, "Random Dataset", None, 1))) -def test_species(mocker, species_name, dataset, - expected_name, chromosome_param): - _c = mocker.patch("base.species.Chromosomes", - return_value=chromosome_param) - test_species = TheSpecies(dataset=dataset, - species_name=species_name) - _c.assert_called_with(species=species_name, - dataset=dataset) - assert test_species.name == expected_name - assert test_species.chromosomes == chromosome_param - - -@pytest.mark.parametrize( - ("name", "length", "mb_length"), - (("Test A", 10000000, 10), - ("Test B", 100, 0.0001))) -def test_create_ind_chromosome(name, length, mb_length): - _ind = IndChromosome(name=name, length=length) - assert _ind.name == name - assert _ind.length == length - assert _ind.mb_length == mb_length - - -@pytest.mark.parametrize( - ("species", "dataset", "expected_call"), - (("bxd", MockDataset(MockGroup("Random")), - ("SELECT Chr_Length.Name, Chr_Length.OrderId, Length " - "FROM Chr_Length, Species WHERE " - "Chr_Length.SpeciesId = Species.SpeciesId AND " - "Species.Name = %s " - "ORDER BY OrderId", ("Bxd",))), - (None, MockDataset(MockGroup("Random")), - ("SELECT Chr_Length.Name, Chr_Length.OrderId, " - "Length FROM Chr_Length, InbredSet WHERE " - "Chr_Length.SpeciesId = InbredSet.SpeciesId AND " - "InbredSet.Name = " - "%s ORDER BY OrderId", ("Random",))))) -def test_create_chromosomes(mocker, species, dataset, expected_call): - mock_conn = mocker.MagicMock() - with mock_conn.cursor() as cursor: - cursor.fetchall.return_value = (("1", 2, 10,), - ("2", 3, 11,), - ("4", 5, 15,),) - _c = Chromosomes(dataset=dataset, species=species) - assert _c.chromosomes(cursor) == OrderedDict([ - ("1", IndChromosome("1", 10)), - ("2", IndChromosome("2", 11)), - ("4", IndChromosome("4", 15)), - ]) - cursor.execute.assert_called_with(*expected_call) diff --git a/wqflask/tests/unit/base/test_trait.py b/wqflask/tests/unit/base/test_trait.py deleted file mode 100644 index 5a27e243..00000000 --- a/wqflask/tests/unit/base/test_trait.py +++ /dev/null @@ -1,262 +0,0 @@ -# -*- coding: utf-8 -*- -"""Tests wqflask/base/trait.py""" -import unittest -from unittest import mock - -from base.trait import GeneralTrait -from base.trait import retrieve_trait_info - - -class TestResponse: - """Mock Test Response after a request""" - @property - def content(self): - """Mock the content from Requests.get(params).content""" - return "[1, 2, 3, 4]" - - -class TestNilResponse: - """Mock Test Response after a request""" - @property - def content(self): - """Mock the content from Requests.get(params).content""" - return "{}" - - -class MockTrait(GeneralTrait): - @property - def wikidata_alias_fmt(self): - return "Mock alias" - - -class TestRetrieveTraitInfo(unittest.TestCase): - """Tests for 'retrieve_trait_info'""" - @mock.patch('base.trait.database_connection') - def test_retrieve_trait_info_with_empty_dataset(self, mock_db): - """Test that an exception is raised when dataset is empty""" - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - with self.assertRaises(ValueError): - retrieve_trait_info(trait=mock.MagicMock(), - dataset={}) - - @mock.patch('base.trait.requests.get') - @mock.patch('base.trait.g', mock.Mock()) - @mock.patch('base.trait.database_connection') - def test_retrieve_trait_info_with_empty_trait_info(self, - mock_db, - requests_mock): - """Empty trait info""" - conn = mock.MagicMock() - cursor = mock.MagicMock() - cursor.fetchone.return_value = {} - conn.cursor.return_value.__enter__.return_value = cursor - mock_db.return_value.__enter__.return_value = conn - requests_mock.return_value = TestNilResponse() - with self.assertRaises(KeyError): - retrieve_trait_info(trait=mock.MagicMock(), - dataset=mock.MagicMock()) - - @mock.patch('base.trait.requests.get') - @mock.patch('base.trait.g', mock.Mock()) - @mock.patch('base.trait.database_connection') - def test_retrieve_trait_info_with_non_empty_trait_info(self, - mock_db, - requests_mock): - """Test that attributes are set""" - mock_dataset = mock.MagicMock() - conn = mock.MagicMock() - cursor = mock.MagicMock() - cursor.fetchone.return_value = [1, 2, 3, 4] - conn.cursor.return_value.__enter__.return_value = cursor - mock_db.return_value.__enter__.return_value = conn - requests_mock.return_value = TestResponse() - type(mock_dataset).display_fields = mock.PropertyMock( - return_value=["a", "b", "c", "d"]) - test_trait = retrieve_trait_info(trait=MockTrait(dataset=mock_dataset), - dataset=mock_dataset) - self.assertEqual(test_trait.a, 1) - self.assertEqual(test_trait.b, 2) - self.assertEqual(test_trait.c, 3) - self.assertEqual(test_trait.d, 4) - - @mock.patch('base.trait.requests.get') - @mock.patch('base.trait.g', mock.Mock()) - @mock.patch('base.trait.database_connection') - def test_retrieve_trait_info_utf8_parsing(self, - mock_db, - requests_mock): - """Test that utf-8 strings are parsed correctly""" - utf_8_string = "test_string" - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - mock_dataset = mock.MagicMock() - requests_mock.return_value = TestResponse() - type(mock_dataset).display_fields = mock.PropertyMock( - return_value=["a", "b", "c", "d"]) - type(mock_dataset).type = 'Publish' - - mock_trait = MockTrait( - dataset=mock_dataset, - pre_publication_description=utf_8_string - ) - trait_attrs = { - "group_code": "test_code", - "pre_publication_description": "test_pre_pub", - "pre_publication_abbreviation": "ファイルを画面毎に見て行くには、次のコマンドを使います。", - "post_publication_description": None, - "pubmed_id": None, - 'year': "2020", - "authors": "Jane Doe かいと", - } - for key, val in list(trait_attrs.items()): - setattr(mock_trait, key, val) - test_trait = retrieve_trait_info(trait=mock_trait, - dataset=mock_dataset) - self.assertEqual(test_trait.abbreviation, - "ファイルを画面毎に見て行くには、次のコマンドを使います。") - self.assertEqual(test_trait.authors, - "Jane Doe かいと") - - - @unittest.skip("Too complicated") - @mock.patch('base.trait.requests.get') - @mock.patch('base.trait.database_connection') - @mock.patch('base.trait.get_resource_id') - def test_retrieve_trait_info_with_non_empty_lrs(self, - resource_id_mock, - mock_db, - requests_mock): - """Test retrieve trait info when lrs has a value""" - resource_id_mock.return_value = 1 - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - with conn.cursor() as cursor: - cursor.fetchone.side_effect = [ - # trait_info = g.db.execute(query).fetchone() - [1, 2, 3, 4], - # trait_qtl = g.db.execute(query).fetchone() - [1, 2.37, 3, 4, 5], - # trait_info = g.db.execute(query).fetchone() - [2.7333, 2.1204] - ] - requests_mock.return_value = None - - mock_dataset = mock.MagicMock() - type(mock_dataset).display_fields = mock.PropertyMock( - return_value=["a", "b", "c", "d"]) - type(mock_dataset).type = "ProbeSet" - type(mock_dataset).name = "RandomName" - - mock_trait = MockTrait( - dataset=mock_dataset, - pre_publication_description="test_string" - ) - trait_attrs = { - "description": "some description", - "probe_target_description": "some description", - "cellid": False, - "chr": 2.733, - "mb": 2.1204 - } - - for key, val in list(trait_attrs.items()): - setattr(mock_trait, key, val) - test_trait = retrieve_trait_info(trait=mock_trait, - dataset=mock_dataset, - get_qtl_info=True) - self.assertEqual(test_trait.LRS_score_repr, - "2.4") - - @unittest.skip("Too complicated") - @mock.patch('base.trait.requests.get') - @mock.patch('base.trait.g') - @mock.patch('base.trait.get_resource_id') - def test_retrieve_trait_info_with_empty_lrs_field(self, - resource_id_mock, - g_mock, - requests_mock): - """Test retrieve trait info with empty lrs field""" - resource_id_mock.return_value = 1 - g_mock.db.execute.return_value.fetchone = mock.Mock() - g_mock.db.execute.return_value.fetchone.side_effect = [ - [1, 2, 3, 4], # trait_info = g.db.execute(query).fetchone() - [1, None, 3, 4, 5], # trait_qtl = g.db.execute(query).fetchone() - [2, 3] # trait_info = g.db.execute(query).fetchone() - ] - requests_mock.return_value = None - - mock_dataset = mock.MagicMock() - type(mock_dataset).display_fields = mock.PropertyMock( - return_value=["a", "b", "c", "d"]) - type(mock_dataset).type = "ProbeSet" - type(mock_dataset).name = "RandomName" - - mock_trait = MockTrait( - dataset=mock_dataset, - pre_publication_description="test_string" - ) - trait_attrs = { - "description": "some description", - "probe_target_description": "some description", - "cellid": False, - "chr": 2.733, - "mb": 2.1204 - } - - for key, val in list(trait_attrs.items()): - setattr(mock_trait, key, val) - test_trait = retrieve_trait_info(trait=mock_trait, - dataset=mock_dataset, - get_qtl_info=True) - self.assertEqual(test_trait.LRS_score_repr, - "N/A") - self.assertEqual(test_trait.LRS_location_repr, - "Chr2: 3.000000") - - @unittest.skip("Too complicated") - @mock.patch('base.trait.requests.get') - @mock.patch('base.trait.g') - @mock.patch('base.trait.get_resource_id') - def test_retrieve_trait_info_with_empty_chr_field(self, - resource_id_mock, - g_mock, - requests_mock): - """Test retrieve trait info with empty chr field""" - resource_id_mock.return_value = 1 - g_mock.db.execute.return_value.fetchone = mock.Mock() - g_mock.db.execute.return_value.fetchone.side_effect = [ - [1, 2, 3, 4], # trait_info = g.db.execute(query).fetchone() - [1, 2, 3, 4, 5], # trait_qtl = g.db.execute(query).fetchone() - [None, 3] # trait_info = g.db.execute(query).fetchone() - ] - - requests_mock.return_value = None - - mock_dataset = mock.MagicMock() - type(mock_dataset).display_fields = mock.PropertyMock( - return_value=["a", "b", "c", "d"]) - type(mock_dataset).type = "ProbeSet" - type(mock_dataset).name = "RandomName" - - mock_trait = MockTrait( - dataset=mock_dataset, - pre_publication_description="test_string" - ) - trait_attrs = { - "description": "some description", - "probe_target_description": "some description", - "cellid": False, - "chr": 2.733, - "mb": 2.1204 - } - - for key, val in list(trait_attrs.items()): - setattr(mock_trait, key, val) - test_trait = retrieve_trait_info(trait=mock_trait, - dataset=mock_dataset, - get_qtl_info=True) - self.assertEqual(test_trait.LRS_score_repr, - "N/A") - self.assertEqual(test_trait.LRS_location_repr, - "N/A") diff --git a/wqflask/tests/unit/base/test_webqtl_case_data.py b/wqflask/tests/unit/base/test_webqtl_case_data.py deleted file mode 100644 index e1555cb4..00000000 --- a/wqflask/tests/unit/base/test_webqtl_case_data.py +++ /dev/null @@ -1,40 +0,0 @@ -"""Tests for wqflask/base/webqtlCaseData.py""" -import unittest - -from wqflask import app # Required because of utility.tools in webqtlCaseData.py -from base.webqtlCaseData import webqtlCaseData - - -class TestWebqtlCaseData(unittest.TestCase): - """Tests for WebqtlCaseData class""" - - def setUp(self): - self.w = webqtlCaseData(name="Test", - value=0, - variance=0.0, - num_cases=10, - name2="Test2") - - def test_webqtl_case_data_repr(self): - self.assertEqual( - repr(self.w), - "<webqtlCaseData> value=0.000 variance=0.000 ndata=10 name=Test name2=Test2" - ) - - def test_class_outlier(self): - self.assertEqual(self.w.class_outlier, "") - - def test_display_value(self): - self.assertEqual(self.w.display_value, "0.000") - self.w.value = None - self.assertEqual(self.w.display_value, "x") - - def test_display_variance(self): - self.assertEqual(self.w.display_variance, "0.000") - self.w.variance = None - self.assertEqual(self.w.display_variance, "x") - - def test_display_num_cases(self): - self.assertEqual(self.w.display_num_cases, "10") - self.w.num_cases = None - self.assertEqual(self.w.display_num_cases, "x") diff --git a/wqflask/tests/unit/utility/__init__.py b/wqflask/tests/unit/utility/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/utility/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/utility/test_authentication_tools.py b/wqflask/tests/unit/utility/test_authentication_tools.py deleted file mode 100644 index fb8de292..00000000 --- a/wqflask/tests/unit/utility/test_authentication_tools.py +++ /dev/null @@ -1,192 +0,0 @@ -"""Tests for authentication tools""" -import unittest -from unittest import mock - -from utility.authentication_tools import check_resource_availability -from utility.authentication_tools import add_new_resource - - -class TestResponse: - """Mock Test Response after a request""" - @property - def content(self): - """Mock the content from Requests.get(params).content""" - return '["foo"]' - - -class TestUser: - """Mock user""" - @property - def user_id(self): - """Mockes user id. Used in Flask.g.user_session.user_id""" - return b"Jane" - -user_id = b"Jane" - - -class TestUserSession: - """Mock user session""" - @property - def user_session(self): - """Mock user session. Mocks Flask.g.user_session object""" - return TestUser() - - -def mock_add_resource(resource_ob, update=False): - return resource_ob - - -class TestCheckResourceAvailability(unittest.TestCase): - """Test methods related to checking the resource availability""" - @mock.patch('utility.authentication_tools.add_new_resource') - @mock.patch('utility.authentication_tools.Redis') - @mock.patch('utility.authentication_tools.g', TestUserSession()) - @mock.patch('utility.authentication_tools.get_resource_id') - def test_check_resource_availability_default_mask( - self, - resource_id_mock, - redis_mock, - add_new_resource_mock): - """Test the resource availability with default mask""" - - resource_id_mock.return_value = 1 - redis_mock.smembers.return_value = [] - test_dataset = mock.MagicMock() - type(test_dataset).type = mock.PropertyMock(return_value="Test") - add_new_resource_mock.return_value = {"default_mask": 2} - self.assertEqual(check_resource_availability(test_dataset, user_id), 2) - - @mock.patch('utility.authentication_tools.requests.get') - @mock.patch('utility.authentication_tools.add_new_resource') - @mock.patch('utility.authentication_tools.Redis') - @mock.patch('utility.authentication_tools.g', TestUserSession()) - @mock.patch('utility.authentication_tools.get_resource_id') - def test_check_resource_availability_non_default_mask( - self, - resource_id_mock, - redis_mock, - add_new_resource_mock, - requests_mock): - """Test the resource availability with non-default mask""" - resource_id_mock.return_value = 1 - redis_mock.smembers.return_value = [] - add_new_resource_mock.return_value = {"default_mask": 2} - requests_mock.return_value = TestResponse() - test_dataset = mock.MagicMock() - type(test_dataset).type = mock.PropertyMock(return_value="Test") - self.assertEqual(check_resource_availability(test_dataset, user_id), - ['foo']) - - @mock.patch('utility.authentication_tools.webqtlConfig.SUPER_PRIVILEGES', - "SUPERUSER") - @mock.patch('utility.authentication_tools.requests.get') - @mock.patch('utility.authentication_tools.add_new_resource') - @mock.patch('utility.authentication_tools.Redis') - @mock.patch('utility.authentication_tools.g', TestUserSession()) - @mock.patch('utility.authentication_tools.get_resource_id') - def test_check_resource_availability_of_super_user( - self, - resource_id_mock, - redis_mock, - add_new_resource_mock, - requests_mock): - """Test the resource availability if the user is the super user""" - resource_id_mock.return_value = 1 - redis_mock.smembers.return_value = [b"Jane"] - add_new_resource_mock.return_value = {"default_mask": 2} - requests_mock.return_value = TestResponse() - test_dataset = mock.MagicMock() - type(test_dataset).type = mock.PropertyMock(return_value="Test") - self.assertEqual(check_resource_availability(test_dataset, user_id), - "SUPERUSER") - - @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES', - "John Doe") - def test_check_resource_availability_string_dataset(self): - """Test the resource availability if the dataset is a string""" - self.assertEqual(check_resource_availability("Test", user_id), - "John Doe") - - @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES', - "John Doe") - def test_check_resource_availability_temp(self): - """Test the resource availability if the dataset is a string""" - test_dataset = mock.MagicMock() - type(test_dataset).type = mock.PropertyMock(return_value="Temp") - self.assertEqual(check_resource_availability(test_dataset, user_id), - "John Doe") - - -class TestAddNewResource(unittest.TestCase): - """Test cases for add_new_resource method""" - @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES', - "John Doe") - @mock.patch('utility.authentication_tools.add_resource', mock_add_resource) - @mock.patch('utility.authentication_tools.get_group_code') - def test_add_new_resource_if_publish_datatype(self, group_code_mock): - """Test add_new_resource if dataset type is 'publish'""" - group_code_mock.return_value = "Test" - test_dataset = mock.MagicMock() - type(test_dataset).type = mock.PropertyMock(return_value="Publish") - type(test_dataset).id = mock.PropertyMock(return_value=10) - expected_value = { - "owner_id": "none", - "default_mask": "John Doe", - "group_masks": {}, - "name": "Test_None", - "data": { - "dataset": 10, - "trait": None - }, - "type": "dataset-publish" - } - self.assertEqual(add_new_resource(test_dataset), - expected_value) - - @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES', - "John Doe") - @mock.patch('utility.authentication_tools.add_resource', mock_add_resource) - @mock.patch('utility.authentication_tools.get_group_code') - def test_add_new_resource_if_geno_datatype(self, group_code_mock): - """Test add_new_resource if dataset type is 'geno'""" - group_code_mock.return_value = "Test" - test_dataset = mock.MagicMock() - type(test_dataset).name = mock.PropertyMock(return_value="Geno") - type(test_dataset).type = mock.PropertyMock(return_value="Geno") - type(test_dataset).id = mock.PropertyMock(return_value=20) - expected_value = { - "owner_id": "none", - "default_mask": "John Doe", - "group_masks": {}, - "name": "Geno", - "data": { - "dataset": 20, - }, - "type": "dataset-geno" - } - self.assertEqual(add_new_resource(test_dataset), - expected_value) - - @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES', - "John Doe") - @mock.patch('utility.authentication_tools.add_resource', mock_add_resource) - @mock.patch('utility.authentication_tools.get_group_code') - def test_add_new_resource_if_other_datatype(self, group_code_mock): - """Test add_new_resource if dataset type is not 'geno' or 'publish'""" - group_code_mock.return_value = "Test" - test_dataset = mock.MagicMock() - type(test_dataset).name = mock.PropertyMock(return_value="Geno") - type(test_dataset).type = mock.PropertyMock(return_value="other") - type(test_dataset).id = mock.PropertyMock(return_value=20) - expected_value = { - "owner_id": "none", - "default_mask": "John Doe", - "group_masks": {}, - "name": "Geno", - "data": { - "dataset": 20, - }, - "type": "dataset-probeset" - } - self.assertEqual(add_new_resource(test_dataset), - expected_value) diff --git a/wqflask/tests/unit/utility/test_chunks.py b/wqflask/tests/unit/utility/test_chunks.py deleted file mode 100644 index 1d349193..00000000 --- a/wqflask/tests/unit/utility/test_chunks.py +++ /dev/null @@ -1,20 +0,0 @@ -"""Test chunking""" - -import unittest - -from utility.chunks import divide_into_chunks - - -class TestChunks(unittest.TestCase): - "Test Utility method for chunking" - - def test_divide_into_chunks(self): - "Check that a list is chunked correctly" - self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 3), - [[1, 2, 7], [3, 22, 8], [5, 22, 333]]) - self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 4), - [[1, 2, 7], [3, 22, 8], [5, 22, 333]]) - self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 5), - [[1, 2], [7, 3], [22, 8], [5, 22], [333]]) - self.assertEqual(divide_into_chunks([], 5), - [[]]) diff --git a/wqflask/tests/unit/utility/test_corestats.py b/wqflask/tests/unit/utility/test_corestats.py deleted file mode 100644 index cf91a248..00000000 --- a/wqflask/tests/unit/utility/test_corestats.py +++ /dev/null @@ -1,55 +0,0 @@ -"""Test Core Stats""" - -import unittest - -from utility.corestats import Stats - - -class TestChunks(unittest.TestCase): - "Test Utility method for chunking" - - def setUp(self): - self.stat_test = Stats((x for x in range(1, 11))) - - def test_stats_sum(self): - """ Test sequence sum """ - self.assertEqual(self.stat_test.sum(), 55) - self.stat_test = Stats([]) - self.assertEqual(self.stat_test.sum(), None) - - def test_stats_count(self): - """ Test sequence count """ - self.assertEqual(self.stat_test.count(), 10) - self.stat_test = Stats([]) - self.assertEqual(self.stat_test.count(), 0) - - def test_stats_min(self): - """ Test min value in sequence""" - self.assertEqual(self.stat_test.min(), 1) - self.stat_test = Stats([]) - self.assertEqual(self.stat_test.min(), None) - - def test_stats_max(self): - """ Test max value in sequence """ - self.assertEqual(self.stat_test.max(), 10) - self.stat_test = Stats([]) - self.assertEqual(self.stat_test.max(), None) - - def test_stats_avg(self): - """ Test avg of sequence """ - self.assertEqual(self.stat_test.avg(), 5.5) - self.stat_test = Stats([]) - self.assertEqual(self.stat_test.avg(), None) - - def test_stats_stdev(self): - """ Test standard deviation of sequence """ - self.assertEqual(self.stat_test.stdev(), 3.0276503540974917) - self.stat_test = Stats([]) - self.assertEqual(self.stat_test.stdev(), None) - - def test_stats_percentile(self): - """ Test percentile of sequence """ - self.assertEqual(self.stat_test.percentile(20), 3.0) - self.assertEqual(self.stat_test.percentile(101), None) - self.stat_test = Stats([]) - self.assertEqual(self.stat_test.percentile(20), None) diff --git a/wqflask/tests/unit/utility/test_corr_result_helpers.py b/wqflask/tests/unit/utility/test_corr_result_helpers.py deleted file mode 100644 index e196fbdf..00000000 --- a/wqflask/tests/unit/utility/test_corr_result_helpers.py +++ /dev/null @@ -1,32 +0,0 @@ -""" Test correlation helper methods """ - -import unittest -from utility.corr_result_helpers import normalize_values, common_keys, normalize_values_with_samples - - -class TestCorrelationHelpers(unittest.TestCase): - """Test methods for normalising lists""" - - def test_normalize_values(self): - """Test that a list is normalised correctly""" - self.assertEqual( - normalize_values([2.3, None, None, 3.2, 4.1, 5], [ - 3.4, 7.2, 1.3, None, 6.2, 4.1]), - ([2.3, 4.1, 5], [3.4, 6.2, 4.1], 3) - ) - - def test_common_keys(self): - """Test that common keys are returned as a list""" - a = dict(BXD1=9.113, BXD2=9.825, BXD14=8.985, BXD15=9.300) - b = dict(BXD1=9.723, BXD3=9.825, BXD14=9.124, BXD16=9.300) - self.assertEqual(sorted(common_keys(a, b)), ['BXD1', 'BXD14']) - - def test_normalize_values_with_samples(self): - """Test that a sample(dict) is normalised correctly""" - self.assertEqual( - normalize_values_with_samples( - dict(BXD1=9.113, BXD2=9.825, BXD14=8.985, - BXD15=9.300, BXD20=9.300), - dict(BXD1=9.723, BXD3=9.825, BXD14=9.124, BXD16=9.300)), - (({'BXD1': 9.113, 'BXD14': 8.985}, {'BXD1': 9.723, 'BXD14': 9.124}, 2)) - ) diff --git a/wqflask/tests/unit/utility/test_formatting.py b/wqflask/tests/unit/utility/test_formatting.py deleted file mode 100644 index 9d3033d1..00000000 --- a/wqflask/tests/unit/utility/test_formatting.py +++ /dev/null @@ -1,33 +0,0 @@ -import unittest -from utility.formatting import numify, commify - - -class TestFormatting(unittest.TestCase): - """Test formatting numbers by numifying or commifying""" - - def test_numify(self): - "Test that a number is correctly converted to a English readable string" - self.assertEqual(numify(1, 'item', 'items'), - 'one item') - self.assertEqual(numify(2, 'book'), 'two') - self.assertEqual(numify(2, 'book', 'books'), 'two books') - self.assertEqual(numify(0, 'book', 'books'), 'zero books') - self.assertEqual(numify(0), 'zero') - self.assertEqual(numify(5), 'five') - self.assertEqual(numify(14, 'book', 'books'), '14 books') - self.assertEqual(numify(999, 'book', 'books'), '999 books') - self.assertEqual(numify(1000000, 'book', 'books'), '1,000,000 books') - self.assertEqual(numify(1956), '1956') - - def test_commify(self): - "Test that commas are added correctly" - self.assertEqual(commify(1), '1') - self.assertEqual(commify(123), '123') - self.assertEqual(commify(1234), '1234') - self.assertEqual(commify(12345), '12,345') - self.assertEqual(commify(1234567890), '1,234,567,890') - self.assertEqual(commify(123.0), '123.0') - self.assertEqual(commify(1234.5), '1234.5') - self.assertEqual(commify(1234.56789), '1234.56789') - self.assertEqual(commify(123456.789), '123,456.789') - self.assertEqual(commify(None), None) diff --git a/wqflask/tests/unit/utility/test_hmac.py b/wqflask/tests/unit/utility/test_hmac.py deleted file mode 100644 index 13d6261d..00000000 --- a/wqflask/tests/unit/utility/test_hmac.py +++ /dev/null @@ -1,51 +0,0 @@ -"""Test hmac utility functions""" - -import unittest -from unittest import mock - -from utility.hmac import data_hmac -from utility.hmac import url_for_hmac -from utility.hmac import hmac_creation - - -class TestHmacUtil(unittest.TestCase): - """Test Utility method for hmac creation""" - - @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"}) - def test_hmac_creation(self): - """Test hmac creation with a utf-8 string""" - self.assertEqual(hmac_creation("ファイ"), "7410466338cfe109e946") - - @mock.patch("utility.hmac.app.config", - {'SECRET_HMAC_CODE': ('\x08\xdf\xfa\x93N\x80' - '\xd9\\H@\\\x9f`\x98d^' - '\xb4a;\xc6OM\x946a\xbc' - '\xfc\x80:*\xebc')}) - def test_hmac_creation_with_cookie(self): - """Test hmac creation with a cookie""" - cookie = "3f4c1dbf-5b56-4260-87d6-f35445bda37e:af4fcf5eace9e7c864ce" - uuid_, _, signature = cookie.partition(":") - self.assertEqual( - hmac_creation(uuid_), - "af4fcf5eace9e7c864ce") - - @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"}) - def test_data_hmac(self): - """Test data_hmac fn with a utf-8 string""" - self.assertEqual(data_hmac("ファイ"), "ファイ:7410466338cfe109e946") - - @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"}) - @mock.patch("utility.hmac.url_for") - def test_url_for_hmac_with_plain_url(self, mock_url): - """Test url_for_hmac without params""" - mock_url.return_value = "https://mock_url.com/ファイ/" - self.assertEqual(url_for_hmac("ファイ"), - "https://mock_url.com/ファイ/?hm=05bc39e659b1948f41e7") - - @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"}) - @mock.patch("utility.hmac.url_for") - def test_url_for_hmac_with_param_in_url(self, mock_url): - """Test url_for_hmac with params""" - mock_url.return_value = "https://mock_url.com/?ファイ=1" - self.assertEqual(url_for_hmac("ファイ"), - "https://mock_url.com/?ファイ=1&hm=4709c1708270644aed79") diff --git a/wqflask/tests/unit/utility/test_type_checking.py b/wqflask/tests/unit/utility/test_type_checking.py deleted file mode 100644 index 48d110c7..00000000 --- a/wqflask/tests/unit/utility/test_type_checking.py +++ /dev/null @@ -1,54 +0,0 @@ -import unittest -from utility.type_checking import is_float -from utility.type_checking import is_int -from utility.type_checking import is_str -from utility.type_checking import get_float -from utility.type_checking import get_int -from utility.type_checking import get_string - - -class TestTypeChecking(unittest.TestCase): - def test_is_float(self): - floats = [2, 1.2, '3.1'] - not_floats = ["String", None, [], ()] - for flt in floats: - results = is_float(flt) - self.assertTrue(results) - for nflt in not_floats: - results = is_float(nflt) - self.assertFalse(results) - - def test_is_int(self): - int_values = [1, 1.1] - not_int_values = ["string", None, [], "1.1"] - for int_val in int_values: - results = is_int(int_val) - self.assertTrue(results) - for not_int in not_int_values: - results = is_int(not_int) - self.assertFalse(results) - - def test_is_str(self): - string_values = [1, False, [], {}, "string_value"] - falsey_values = [None] - for string_val in string_values: - results = is_str(string_val) - self.assertTrue(results) - for non_string in falsey_values: - results = is_str(non_string) - self.assertFalse(results) - - def test_get_float(self): - vars_object = {"min_value": "12"} - results = get_float(vars_object, "min_value") - self.assertEqual(results, 12.0) - - def test_get_int(self): - vars_object = {"lx_value": "1"} - results = get_int(vars_object, "lx_value") - self.assertEqual(results, 1) - - def test_get_string(self): - string_object = {"mx_value": 1} - results = get_string(string_object, "mx_value") - self.assertEqual(results, "1")
\ No newline at end of file diff --git a/wqflask/tests/unit/wqflask/__init__.py b/wqflask/tests/unit/wqflask/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/wqflask/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/wqflask/api/__init__.py b/wqflask/tests/unit/wqflask/api/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/wqflask/api/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py deleted file mode 100644 index 53e1b9a2..00000000 --- a/wqflask/tests/unit/wqflask/api/test_correlation.py +++ /dev/null @@ -1,175 +0,0 @@ -import unittest -from unittest import mock -from wqflask import app -from collections import OrderedDict -from wqflask.api.correlation import init_corr_params -from wqflask.api.correlation import convert_to_mouse_gene_id -from wqflask.api.correlation import do_literature_correlation_for_all_traits -from wqflask.api.correlation import get_sample_r_and_p_values -from wqflask.api.correlation import calculate_results - - -class AttributeSetter: - def __init__(self, obj): - for k, v in obj.items(): - setattr(self, k, v) - - -class MockDataset(AttributeSetter): - def get_trait_data(self): - return None - - def retrieve_genes(self, id=None): - return {"TT-1": "GH-1", "TT-2": "GH-2", "TT-3": "GH-3"} - - -class TestCorrelations(unittest.TestCase): - def setUp(self): - self.app_context = app.app_context() - self.app_context.push() - - def tearDown(self): - self.app_context.pop() - - def test_init_corr_params(self): - start_vars = {"return_count": "3", "type": "T1", "method": "spearman"} - - corr_params_results = init_corr_params(start_vars=start_vars) - expected_results = {"return_count": 3, "type": "T1", "method": "spearman"} - - self.assertEqual(corr_params_results, expected_results) - - @mock.patch("wqflask.api.correlation.database_connection") - def test_convert_to_mouse_gene_id(self, mock_db): - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - with conn.cursor() as cursor: - cursor.fetchone.side_effect = [("MG-1",), ("MG-2",)] - - self.assertEqual( - convert_to_mouse_gene_id(species="Other", gene_id=""), None - ) - self.assertEqual( - convert_to_mouse_gene_id(species="mouse", gene_id="MG-4"), "MG-4" - ) - self.assertEqual( - convert_to_mouse_gene_id(species="rat", gene_id="R1"), "MG-1" - ) - self.assertEqual( - convert_to_mouse_gene_id(species="human", gene_id="H1"), "MG-2" - ) - - @mock.patch("wqflask.api.correlation.database_connection") - @mock.patch("wqflask.api.correlation.convert_to_mouse_gene_id") - def test_do_literature_correlation_for_all_traits( - self, mock_convert_to_mouse_geneid, mock_db - ): - mock_convert_to_mouse_geneid.side_effect = ["MG-1", "MG-2;", "MG-3", "MG-4"] - - trait_geneid_dict = {"TT-1": "GH-1", "TT-2": "GH-2", "TT-3": "GH-3"} - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - with conn.cursor() as cursor: - cursor.fetchone.side_effect = [("V1",), ("V2",), ("V3",)] - this_trait = AttributeSetter({"geneid": "GH-1"}) - target_dataset = AttributeSetter( - {"group": AttributeSetter({"species": "rat"})} - ) - results = do_literature_correlation_for_all_traits( - this_trait=this_trait, - target_dataset=target_dataset, - trait_geneid_dict=trait_geneid_dict, - corr_params={}, - ) - expected_results = { - "TT-1": ["GH-1", 0], - "TT-2": ["GH-2", "V1"], - "TT-3": ["GH-3", "V2"], - } - self.assertEqual(results, expected_results) - - @mock.patch("wqflask.api.correlation.corr_result_helpers.normalize_values") - def test_get_sample_r_and_p_values(self, mock_normalize): - - group = AttributeSetter( - {"samplelist": ["S1", "S2", "S3", "S4", "S5", "S6", "S7"]} - ) - target_dataset = AttributeSetter({"group": group}) - - target_vals = [3.4, 6.2, 4.1, 3.4, 1.2, 5.6] - trait_data = { - "S1": AttributeSetter({"value": 2.3}), - "S2": AttributeSetter({"value": 1.1}), - "S3": AttributeSetter({"value": 6.3}), - "S4": AttributeSetter({"value": 3.6}), - "S5": AttributeSetter({"value": 4.1}), - "S6": AttributeSetter({"value": 5.0}), - } - this_trait = AttributeSetter({"data": trait_data}) - mock_normalize.return_value = ( - [2.3, 1.1, 6.3, 3.6, 4.1, 5.0], - [3.4, 6.2, 4.1, 3.4, 1.2, 5.6], - 6, - ) - mock_normalize.side_effect = [ - ([2.3, 1.1, 6.3, 3.6, 4.1, 5.0], [3.4, 6.2, 4.1, 3.4, 1.2, 5.6], 6), - ([2.3, 1.1, 6.3, 3.6, 4.1, 5.0], [3.4, 6.2, 4.1, 3.4, 1.2, 5.6], 6), - ([2.3, 1.1, 1.4], [3.4, 6.2, 4.1], 3), - ] - - results_pearsonr = get_sample_r_and_p_values( - this_trait=this_trait, - this_dataset={}, - target_vals=target_vals, - target_dataset=target_dataset, - type="pearson", - ) - results_spearmanr = get_sample_r_and_p_values( - this_trait=this_trait, - this_dataset={}, - target_vals=target_vals, - target_dataset=target_dataset, - type="spearman", - ) - results_num_overlap = get_sample_r_and_p_values( - this_trait=this_trait, - this_dataset={}, - target_vals=target_vals, - target_dataset=target_dataset, - type="pearson", - ) - expected_pearsonr = [-0.21618688834430866, 0.680771605997119, 6] - expected_spearmanr = [-0.11595420713048969, 0.826848213385815, 6] - for i, val in enumerate(expected_pearsonr): - self.assertAlmostEqual(val, results_pearsonr[i], 4) - for i, val in enumerate(expected_spearmanr): - self.assertAlmostEqual(val, results_spearmanr[i], 4) - self.assertEqual(results_num_overlap, None) - - @mock.patch("wqflask.api.correlation.do_literature_correlation_for_all_traits") - def test_calculate_results(self, literature_correlation): - - literature_correlation.return_value = { - "TT-1": ["GH-1", 0], - "TT-2": ["GH-2", 3], - "TT-3": ["GH-3", 1], - } - - this_dataset = MockDataset({"group": AttributeSetter({"species": "rat"})}) - target_dataset = MockDataset({"group": AttributeSetter({"species": "rat"})}) - this_trait = AttributeSetter({"geneid": "GH-1"}) - corr_params = {"type": "literature"} - sorted_results = calculate_results( - this_trait=this_trait, - this_dataset=this_dataset, - target_dataset=target_dataset, - corr_params=corr_params, - ) - expected_results = { - "TT-2": ["GH-2", 3], - "TT-3": ["GH-3", 1], - "TT-1": ["GH-1", 0], - } - - self.assertTrue(isinstance(sorted_results, OrderedDict)) - self.assertEqual(dict(sorted_results), expected_results) diff --git a/wqflask/tests/unit/wqflask/api/test_gen_menu.py b/wqflask/tests/unit/wqflask/api/test_gen_menu.py deleted file mode 100644 index 7e477da2..00000000 --- a/wqflask/tests/unit/wqflask/api/test_gen_menu.py +++ /dev/null @@ -1,423 +0,0 @@ -"""Test cases for wqflask.api.gen_menu""" -import unittest -from unittest import mock - -from wqflask.api.gen_menu import gen_dropdown_json -from wqflask.api.gen_menu import get_groups -from wqflask.api.gen_menu import get_types -from wqflask.api.gen_menu import get_datasets -from wqflask.api.gen_menu import phenotypes_exist -from wqflask.api.gen_menu import genotypes_exist -from wqflask.api.gen_menu import build_datasets -from wqflask.api.gen_menu import build_types - - -class TestGenMenu(unittest.TestCase): - """Tests for the gen_menu module""" - - def setUp(self): - self.test_group = { - 'mouse': [ - ['H_T1', - 'H_T', - 'Family:DescriptionA' - ], - ['H_T2', "H_T'", 'Family:None'] - ], - 'human': [ - ['BXD', 'BXD', 'Family:None'], - ['HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)', - 'Family:Test'] - ] - } - - self.test_type = { - 'mouse': { - 'H_T2': [('Phenotypes', - 'Traits and Cofactors', - 'Phenotypes'), - ('Genotypes', - 'DNA Markers and SNPs', - 'Genotypes'), - ['M', 'M', 'Molecular Trait Datasets']], - 'H_T1': [('Phenotypes', - 'Traits and Cofactors', - 'Phenotypes'), - ('Genotypes', - 'DNA Markers and SNPs', - 'Genotypes'), - ['M', 'M', 'Molecular Trait Datasets']] - }, - 'human': { - 'HLC': [('Phenotypes', - 'Traits and Cofactors', - 'Phenotypes'), - ('Genotypes', - 'DNA Markers and SNPs', - 'Genotypes'), - ['M', 'M', 'Molecular Trait Datasets']], - 'BXD': [('Phenotypes', - 'Traits and Cofactors', - 'Phenotypes'), - ('Genotypes', - 'DNA Markers and SNPs', - 'Genotypes'), - ['M', 'M', 'Molecular Trait Datasets']] - } - } - - def test_get_groups(self): - """Test that species groups are grouped correctly""" - db_mock = mock.MagicMock() - with db_mock.cursor() as cursor: - cursor.fetchall.side_effect = [ - # Mouse - (('BXD', 'BXD', None), - ('HLC', ('Liver: Normal Gene Expression ' - 'with Genotypes (Merck)'), - 'Test')), - # Human - (('H_T1', "H_T", "DescriptionA"), - ('H_T2', "H_T'", None)) - ] - self.assertEqual(get_groups([["human", "Human"], - ["mouse", "Mouse"]], - db_mock), - self.test_group) - - for name in ["mouse", "human"]: - cursor.execute.assert_any_call( - ("SELECT InbredSet.Name, InbredSet.FullName, " - "IFNULL(InbredSet.Family, 'None') " - "FROM InbredSet, Species WHERE Species.Name " - "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by " - "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, " - "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, " - "InbredSet.FullName) ASC, InbredSet.FullName ASC, " - "InbredSet.MenuOrderId ASC").format(name) - ) - - def test_phenotypes_exist_called_with_correct_query(self): - """Test that phenotypes_exist is called with the correct query""" - db_mock = mock.MagicMock() - with db_mock.cursor() as cursor: - cursor.fetchone.return_value = None - phenotypes_exist("test", db_mock) - cursor.execute.assert_called_with( - "SELECT Name FROM PublishFreeze " - "WHERE PublishFreeze.Name = 'testPublish'" - ) - - def test_phenotypes_exist_with_falsy_values(self): - """Test that phenotype check returns correctly when given - a None value""" - db_mock = mock.MagicMock() - with db_mock.cursor() as cursor: - for x in [None, False, (), [], ""]: - cursor.fetchone.return_value = x - self.assertFalse(phenotypes_exist("test", db_mock)) - - def test_phenotypes_exist_with_truthy_value(self): - """Test that phenotype check returns correctly when given Truthy""" - db_mock = mock.MagicMock() - with db_mock.cursor() as conn: - with conn.cursor() as cursor: - for x in ["x", ("result"), ["result"], [1]]: - cursor.fetchone.return_value = (x) - self.assertTrue(phenotypes_exist("test", db_mock)) - - def test_genotypes_exist_called_with_correct_query(self): - """Test that genotypes_exist is called with the correct query""" - db_mock = mock.MagicMock() - with db_mock.cursor() as cursor: - cursor.fetchone.return_value = None - genotypes_exist("test", db_mock) - cursor.execute.assert_called_with( - "SELECT Name FROM GenoFreeze WHERE " - "GenoFreeze.Name = 'testGeno'" - ) - - def test_genotypes_exist_with_falsy_values(self): - """Test that genotype check returns correctly when given a None value - - """ - db_mock = mock.MagicMock() - with db_mock.cursor() as cursor: - for x in [None, False, (), [], ""]: - cursor.fetchone.return_value = x - self.assertFalse(genotypes_exist("test", db_mock)) - - def test_genotypes_exist_with_truthy_value(self): - """Test that genotype check returns correctly when given Truthy """ - db_mock = mock.MagicMock() - with db_mock.cursor() as cursor: - for x in ["x", ("result"), ["result"], [1]]: - cursor.fetchone.return_value = (x) - self.assertTrue(phenotypes_exist("test", db_mock)) - - def test_build_datasets_with_type_phenotypes(self): - """Test that correct dataset is returned for a phenotype type""" - db_mock = mock.MagicMock() - with db_mock.cursor() as cursor: - cursor.fetchall.return_value = ( - (602, "BXDPublish", "BXD Published Phenotypes"), - ) - self.assertEqual(build_datasets("Mouse", "BXD", - "Phenotypes", db_mock), - [['602', "BXDPublish", - "BXD Published Phenotypes"]]) - cursor.execute.assert_called_with( - "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " - + "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " - + "InbredSet WHERE InbredSet.Name = 'BXD' AND " - + "PublishFreeze.InbredSetId = InbredSet.Id AND " - + "InfoFiles.InfoPageName = PublishFreeze.Name " - + "ORDER BY PublishFreeze.CreateTime ASC" - ) - self.assertEqual(build_datasets("Mouse", "MDP", - "Phenotypes", db_mock), - [['602', "BXDPublish", - "Mouse Phenome Database"]]) - - cursor.fetchall.return_value = () - cursor.fetchone.return_value = ( - "BXDPublish", "Mouse Phenome Database" - ) - self.assertEqual(build_datasets("Mouse", "MDP", - "Phenotypes", db_mock), - [["None", "BXDPublish", - "Mouse Phenome Database"]]) - - def test_build_datasets_with_type_phenotypes_and_no_results(self): - """Test that correct dataset is returned for a phenotype type with no - results - - """ - db_mock = mock.MagicMock() - with db_mock.cursor() as cursor: - cursor.fetchall.return_value = None - cursor.fetchone.return_value = (121, - "text value") - self.assertEqual(build_datasets("Mouse", "BXD", - "Phenotypes", db_mock), - [["None", "121", - "text value"]]) - cursor.execute.assert_called_with( - "SELECT PublishFreeze.Name, PublishFreeze.FullName " - "FROM PublishFreeze, InbredSet " - "WHERE InbredSet.Name = 'BXD' AND " - "PublishFreeze.InbredSetId = InbredSet.Id " - "ORDER BY PublishFreeze.CreateTime ASC" - ) - - def test_build_datasets_with_type_genotypes(self): - """Test that correct dataset is returned for a phenotype type""" - db_mock = mock.MagicMock() - with db_mock.cursor() as cursor: - cursor.fetchone.return_value = ( - 635, "HLCPublish", "HLC Published Genotypes" - ) - self.assertEqual(build_datasets("Mouse", "HLC", - "Genotypes", db_mock), - [["635", "HLCGeno", "HLC Genotypes"]]) - cursor.execute.assert_called_with( - "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, " - "GenoFreeze, InbredSet WHERE InbredSet.Name = 'HLC' AND " - "GenoFreeze.InbredSetId = InbredSet.Id AND " - "InfoFiles.InfoPageName = GenoFreeze.ShortName " - "ORDER BY GenoFreeze.CreateTime DESC" - ) - cursor.fetchone.return_value = () - self.assertEqual(build_datasets("Mouse", "HLC", - "Genotypes", db_mock), - [["None", "HLCGeno", "HLC Genotypes"]]) - - def test_build_datasets_with_type_mrna(self): - """Test that correct dataset is returned for a mRNA - expression/ Probeset""" - db_mock = mock.MagicMock() - with db_mock.cursor() as cursor: - cursor.fetchall.return_value = ( - (112, "HC_M2_0606_P", - "Hippocampus Consortium M430v2 (Jun06) PDNN"), ) - self.assertEqual(build_datasets("Mouse", - "HLC", "mRNA", db_mock), - [["112", 'HC_M2_0606_P', - "Hippocampus Consortium M430v2 (Jun06) PDNN" - ]]) - cursor.execute.assert_called_once_with( - "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " - "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " - "ProbeFreeze, InbredSet, Tissue, Species WHERE " - "Species.Name = 'Mouse' AND Species.Id = " - "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND " - "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id AND " - "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " - "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id AND " - "ProbeSetFreeze.public > 0 " - "ORDER BY -ProbeSetFreeze.OrderList DESC, " - "ProbeSetFreeze.CreateTime DESC") - - @mock.patch('wqflask.api.gen_menu.build_datasets') - def test_build_types(self, datasets_mock): - """Test that correct tissue metadata is returned""" - db_mock = mock.MagicMock() - datasets_mock.return_value = [ - ["112", 'HC_M2_0606_P', - "Hippocampus Consortium M430v2 (Jun06) PDNN"] - ] - with db_mock.cursor() as cursor: - cursor.fetchall.return_value = ( - ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue') - ) - self.assertEqual(build_types('mouse', 'random group', db_mock), - [['M', 'M', 'Molecular Traits'], - ['H', 'H', 'Molecular Traits'], - ['R', 'R', 'Molecular Traits']]) - cursor.execute.assert_called_once_with( - "SELECT DISTINCT Tissue.Name " - "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " - "Tissue, Species WHERE Species.Name = 'mouse' " - "AND Species.Id = InbredSet.SpeciesId AND " - "InbredSet.Name = 'random group' AND " - "ProbeFreeze.TissueId = Tissue.Id AND " - "ProbeFreeze.InbredSetId = InbredSet.Id AND " - "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " - "ORDER BY Tissue.Name" - ) - - @mock.patch('wqflask.api.gen_menu.build_types') - @mock.patch('wqflask.api.gen_menu.genotypes_exist') - @mock.patch('wqflask.api.gen_menu.phenotypes_exist') - def test_get_types_with_existing_genotype_and_phenotypes( - self, - phenotypes_exist_mock, - genotypes_exist_mock, - build_types_mock): - """Test that build types are constructed correctly if phenotypes and genotypes - exist - - """ - phenotypes_exist_mock.return_value = True - genotypes_exist_mock.return_value = True - - expected_result = self.test_type - - build_types_mock.return_value = [ - ['M', 'M', 'Molecular Trait Datasets'] - ] - self.assertEqual(get_types(self.test_group, - mock.MagicMock()), - expected_result) - - @mock.patch('wqflask.api.gen_menu.build_types') - @mock.patch('wqflask.api.gen_menu.genotypes_exist') - @mock.patch('wqflask.api.gen_menu.phenotypes_exist') - def test_get_types_with_buildtype_and_non_existent_genotype_and_phenotypes( - self, - phenotypes_exist_mock, - genotypes_exist_mock, - build_types_mock): - """Test that build types are constructed correctly if phenotypes_exist and - genotypes_exist are false but build_type is falsy - - """ - phenotypes_exist_mock.return_value = False - genotypes_exist_mock.return_value = False - - build_types_mock.return_value = [] - self.assertEqual(get_types(self.test_group, mock.MagicMock()), - {'mouse': {}, 'human': {}}) - - @mock.patch('wqflask.api.gen_menu.build_types') - @mock.patch('wqflask.api.gen_menu.genotypes_exist') - @mock.patch('wqflask.api.gen_menu.phenotypes_exist') - def test_get_types_with_non_existent_genotype_phenotypes_and_buildtype( - self, - phenotypes_exist_mock, - genotypes_exist_mock, - build_types_mock): - """Test that build types are constructed correctly if phenotypes_exist, - genotypes_exist and build_types are truthy - - """ - phenotypes_exist_mock.return_value = False - genotypes_exist_mock.return_value = False - - build_types_mock.return_value = [ - ['M', 'M', 'Molecular Trait Datasets'] - ] - expected_result = { - 'mouse': { - 'H_T2': [['M', 'M', 'Molecular Trait Datasets']], - 'H_T1': [['M', 'M', 'Molecular Trait Datasets']]}, - 'human': { - 'HLC': [['M', 'M', 'Molecular Trait Datasets']], - 'BXD': [['M', 'M', 'Molecular Trait Datasets']]}} - self.assertEqual(get_types(self.test_group, mock.MagicMock()), - expected_result) - - @mock.patch('wqflask.api.gen_menu.build_datasets') - def test_get_datasets_with_existent_datasets(self, - build_datasets_mock): - """Test correct dataset is returned with existent build_datasets""" - build_datasets_mock.return_value = "Test" - expected_result = { - 'mouse': { - 'H_T2': {'Genotypes': 'Test', - 'M': 'Test', - 'Phenotypes': 'Test'}, - 'H_T1': {'Genotypes': 'Test', - 'M': 'Test', - 'Phenotypes': 'Test'}}, - 'human': {'HLC': {'Genotypes': 'Test', - 'M': 'Test', - 'Phenotypes': 'Test'}, - 'BXD': {'Genotypes': 'Test', - 'M': 'Test', - 'Phenotypes': 'Test'}}} - self.assertEqual(get_datasets(self.test_type, mock.MagicMock()), - expected_result) - - @mock.patch('wqflask.api.gen_menu.build_datasets') - def test_get_datasets_with_non_existent_datasets(self, - build_datasets_mock): - """Test correct dataset is returned with non-existent build_datasets""" - build_datasets_mock.return_value = None - expected_result = { - 'mouse': { - 'H_T2': {}, - 'H_T1': {}}, - 'human': {'HLC': {}, - 'BXD': {}}} - self.assertEqual(get_datasets(self.test_type, mock.MagicMock()), - expected_result) - - @mock.patch('wqflask.api.gen_menu.get_datasets') - @mock.patch('wqflask.api.gen_menu.get_types') - @mock.patch('wqflask.api.gen_menu.get_groups') - @mock.patch('wqflask.api.gen_menu.get_all_species') - def test_gen_dropdown_json(self, - species_mock, - groups_mock, - types_mock, - datasets_mock): - "Test that the correct dictionary is constructed properly" - species_mock.return_value = ("speciesA speciesB speciesC speciesD" - .split(" ")) - datasets_mock.return_value = ("datasetA datasetB datasetC datasetD" - .split(" ")) - groups_mock.return_value = ("groupA groupB groupC groupD" - .split(" ")) - types_mock.return_value = ("typeA typeB typeC typeD" - .split(" ")) - datasets_mock.return_value = ("datasetA datasetB datasetC datasetD" - .split(" ")) - - expected_result = { - 'datasets': ['datasetA', 'datasetB', 'datasetC', 'datasetD'], - 'types': ['typeA', 'typeB', 'typeC', 'typeD'], - 'groups': ['groupA', 'groupB', 'groupC', 'groupD'], - 'species': ['speciesA', 'speciesB', 'speciesC', 'speciesD']} - - self.assertEqual(gen_dropdown_json(mock.MagicMock()), expected_result) diff --git a/wqflask/tests/unit/wqflask/api/test_mapping.py b/wqflask/tests/unit/wqflask/api/test_mapping.py deleted file mode 100644 index 006e9826..00000000 --- a/wqflask/tests/unit/wqflask/api/test_mapping.py +++ /dev/null @@ -1,113 +0,0 @@ -import unittest -from unittest import mock -from wqflask.api.mapping import initialize_parameters -from wqflask.api.mapping import do_mapping_for_api - - -class AttributeSetter: - def __init__(self, obj): - for key, value in obj.items(): - setattr(self, key, value) - - -class MockGroup(AttributeSetter): - def get_marker(self): - self.markers = [] - - -class TestMapping(unittest.TestCase): - - def test_initialize_parameters(self): - expected_results = { - "format": "json", - "limit_to": False, - "mapping_method": "gemma", - "maf": 0.01, - "use_loco": True, - "num_perm": 0, - "perm_check": False, - "transform": False, - "genofile": False - } - - results = initialize_parameters( - start_vars={}, dataset={}, this_trait={}) - self.assertEqual(results, expected_results) - - start_vars = { - "format": "F1", - "limit_to": "1", - "mapping_method": "rqtl", - "control_marker": True, - "pair_scan": "true", - "interval_mapping": "true", - "use_loco": "true", - "num_perm": "14", - "transform": "qnorm", - "genofile": "BXD.8.geno" - } - - results_2 = initialize_parameters( - start_vars=start_vars, dataset={}, this_trait={}) - expected_results = { - "format": "F1", - "limit_to": 1, - "mapping_method": "gemma", - "maf": 0.01, - "use_loco": True, - "num_perm": 14, - "perm_check": "ON", - "transform": "qnorm", - "genofile": "BXD.8.geno" - } - - self.assertEqual(results_2, expected_results) - - @mock.patch("wqflask.api.mapping.rqtl_mapping.run_rqtl") - @mock.patch("wqflask.api.mapping.gemma_mapping.run_gemma") - @mock.patch("wqflask.api.mapping.initialize_parameters") - @mock.patch("wqflask.api.mapping.retrieve_sample_data") - @mock.patch("wqflask.api.mapping.create_trait") - @mock.patch("wqflask.api.mapping.data_set.create_dataset") - def test_do_mapping_for_api(self, mock_create_dataset, mock_trait, mock_retrieve_sample, mock_param, run_gemma, run_rqtl_geno): - start_vars = { - "db": "Temp", - "trait_id": "dewf3232rff2", - "format": "F1", - "mapping_method": "gemma", - "use_loco": True - - } - sampleList = ["S1", "S2", "S3", "S4"] - samplelist = ["S1", "S2", "S4"] - dataset = AttributeSetter({"group": samplelist}) - this_trait = AttributeSetter({}) - trait_data = AttributeSetter({ - "data": { - "item1": AttributeSetter({"name": "S1", "value": "S1_value"}), - "item2": AttributeSetter({"name": "S2", "value": "S2_value"}), - "item3": AttributeSetter({"name": "S3", "value": "S3_value"}), - - } - }) - trait = AttributeSetter({ - "data": trait_data - }) - - dataset.return_value = dataset - mock_trait.return_value = this_trait - - mock_retrieve_sample.return_value = trait - mock_param.return_value = { - "format": "F1", - "limit_to": False, - "mapping_method": "gemma", - "maf": 0.01, - "use_loco": "True", - "num_perm": 14, - "perm_check": "ON" - } - - run_gemma.return_value = ["results"] - results = do_mapping_for_api(start_vars=start_vars) - self.assertEqual(results, ("results", None)) diff --git a/wqflask/tests/unit/wqflask/api/test_markdown_routes.py b/wqflask/tests/unit/wqflask/api/test_markdown_routes.py deleted file mode 100644 index 4f575c4c..00000000 --- a/wqflask/tests/unit/wqflask/api/test_markdown_routes.py +++ /dev/null @@ -1,54 +0,0 @@ -"""Test functions for wqflask/api/markdown.py""" - -import unittest -from unittest import mock - -from dataclasses import dataclass -from wqflask.api.markdown import render_markdown - - -@dataclass -class MockRequests404: - status_code: int = 404 - - -@dataclass -class MockRequests200: - status_code: int = 200 - content: str = b""" -# Glossary -This is some content - -## Sub-heading -This is another sub-heading""" - - -class TestMarkdownRoutesFunctions(unittest.TestCase): - """Test cases for functions in markdown""" - - @mock.patch('wqflask.api.markdown.requests.get') - def test_render_markdown_when_fetching_locally(self, requests_mock): - requests_mock.return_value = MockRequests404() - markdown_content = render_markdown("general/glossary/glossary.md") - requests_mock.assert_called_with( - "https://raw.githubusercontent.com" - "/genenetwork/gn-docs/" - "master/general/" - "glossary/glossary.md") - self.assertRegex(markdown_content, - "Content for general/glossary/glossary.md not available.") - - @mock.patch('wqflask.api.markdown.requests.get') - def test_render_markdown_when_fetching_remotely(self, requests_mock): - requests_mock.return_value = MockRequests200() - markdown_content = render_markdown("general/glossary/glossary.md") - requests_mock.assert_called_with( - "https://raw.githubusercontent.com" - "/genenetwork/gn-docs/" - "master/general/" - "glossary/glossary.md") - self.assertEqual("""<h1>Glossary</h1> -<p>This is some content</p> -<h2>Sub-heading</h2> -<p>This is another sub-heading</p>""", - markdown_content) diff --git a/wqflask/tests/unit/wqflask/correlation/__init__.py b/wqflask/tests/unit/wqflask/correlation/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/wqflask/correlation/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py deleted file mode 100644 index bb07d41e..00000000 --- a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py +++ /dev/null @@ -1,21 +0,0 @@ -"""module contains tests for correlation functions""" - -import unittest -from unittest import mock - -from wqflask.correlation.correlation_functions import get_trait_symbol_and_tissue_values -from wqflask.correlation.correlation_functions import cal_zero_order_corr_for_tiss - - -def test_tissue_corr_computation(mocker): - """Test for cal_zero_order_corr_for_tiss""" - primary_values = [9.288, 9.313, 8.988, 9.660, 8.21] - target_values = [9.586, 8.498, 9.362, 8.820, 8.786] - _m = mocker.patch(("wqflask.correlation.correlation_functions." - "compute_corr_coeff_p_value"), - return_value=(0.51, 0.7)) - results = cal_zero_order_corr_for_tiss(primary_values, target_values) - _m.assert_called_once_with( - primary_values=primary_values, target_values=target_values, - corr_method="pearson") - assert len(results) == 3 diff --git a/wqflask/tests/unit/wqflask/correlation/test_correlation_gn3.py b/wqflask/tests/unit/wqflask/correlation/test_correlation_gn3.py deleted file mode 100644 index e1bd6d86..00000000 --- a/wqflask/tests/unit/wqflask/correlation/test_correlation_gn3.py +++ /dev/null @@ -1,14 +0,0 @@ -"""this module contains tests for code used in integrating to gn3 api""" -from unittest import TestCase -from base.data_set import create_dataset - -class TestCorrelation(TestCase): - - def test_create_dataset(self): - """test for creating datasets""" - - pass - def test_fetch_dataset_info(self): - """test for fetching dataset info data""" - - pass diff --git a/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py deleted file mode 100644 index e29b18ca..00000000 --- a/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py +++ /dev/null @@ -1,42 +0,0 @@ -import unittest -from unittest import mock -from wqflask.correlation.show_corr_results import get_header_fields - - -class AttributeSetter: - def __init__(self, trait_obj): - for key, value in trait_obj.items(): - setattr(self, key, value) - - -class TestShowCorrResults(unittest.TestCase): - def test_get_header_fields(self): - expected = [ - ['Index', - 'Record', - 'Symbol', - 'Description', - 'Location', - 'Mean', - 'Sample rho', - 'N', - 'Sample p(rho)', - 'Lit rho', - 'Tissue rho', - 'Tissue p(rho)', - 'Max LRS', - 'Max LRS Location', - 'Additive Effect'], - - ['Index', - 'ID', - 'Location', - 'Sample r', - 'N', - 'Sample p(r)'] - - ] - result1 = get_header_fields("ProbeSet", "spearman") - result2 = get_header_fields("Other", "Other") - self.assertEqual(result1, expected[0]) - self.assertEqual(result2, expected[1]) diff --git a/wqflask/tests/unit/wqflask/marker_regression/__init__.py b/wqflask/tests/unit/wqflask/marker_regression/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/wqflask/marker_regression/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/wqflask/marker_regression/genotype/bimbam/file_geno.txt b/wqflask/tests/unit/wqflask/marker_regression/genotype/bimbam/file_geno.txt deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/wqflask/marker_regression/genotype/bimbam/file_geno.txt +++ /dev/null diff --git a/wqflask/tests/unit/wqflask/marker_regression/genotype/bimbam/file_snps.txt b/wqflask/tests/unit/wqflask/marker_regression/genotype/bimbam/file_snps.txt deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/wqflask/marker_regression/genotype/bimbam/file_snps.txt +++ /dev/null diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py b/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py deleted file mode 100644 index f4869c45..00000000 --- a/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py +++ /dev/null @@ -1,159 +0,0 @@ -import unittest - -import htmlgen as HT -from wqflask.marker_regression.display_mapping_results import ( - DisplayMappingResults, - HtmlGenWrapper -) - - -class TestDisplayMappingResults(unittest.TestCase): - """Basic Methods to test Mapping Results""" - - def test_pil_colors(self): - """Test that colors use PILLOW color format""" - self.assertEqual(DisplayMappingResults.CLICKABLE_WEBQTL_REGION_COLOR, - (245, 211, 211)) - - -class TestHtmlGenWrapper(unittest.TestCase): - """Test Wrapper around HTMLGen""" - - def test_create_image(self): - """Test HT.Image method""" - self.assertEqual( - str(HtmlGenWrapper.create_image_tag(src="test.png", - alt="random", - border="0", - width="10", - height="13", - usemap="#webqtlmap")), - ("""<img alt="random" border="0" height="13" """ - """src="test.png" usemap="#webqtlmap" """ - """width="10"/>""") - ) - - def test_create_form(self): - """Test HT.Form method""" - test_form = HtmlGenWrapper.create_form_tag( - cgi="/testing/", - enctype='multipart/form-data', - name="formName", - submit=HtmlGenWrapper.create_input_tag( - type_='hidden', name='Default_Name') - ) - test_image = HtmlGenWrapper.create_image_tag( - src="test.png", - alt="random", - border="0", - width="10", - height="13", - usemap="#webqtlmap" - ) - self.assertEqual( - str(test_form).replace("\n", ""), - ("""<form action="/testing/" enctype="multipart/form-data" """ - """method="POST" """ - """name="formName"><input name="Default_Name" """ - """type="hidden"/></form>""")) - hddn = { - 'FormID': 'showDatabase', - 'ProbeSetID': '_', - 'database': "TestGeno", - 'CellID': '_', - 'RISet': "Test", - 'incparentsf1': 'ON' - } - for key in hddn.keys(): - test_form.append( - HtmlGenWrapper.create_input_tag( - name=key, - value=hddn[key], - type_='hidden')) - test_form.append(test_image) - - self.assertEqual(str(test_form).replace("\n", ""), ( - """<form action="/testing/" enctype="multipart/form-data" """ - """method="POST" name="formName">""" - """<input name="Default_Name" type="hidden"/>""" - """<input name="FormID" type="hidden" value="showDatabase"/>""" - """<input name="ProbeSetID" type="hidden" value="_"/>""" - """<input name="database" type="hidden" value="TestGeno"/>""" - """<input name="CellID" type="hidden" value="_"/>""" - """<input name="RISet" type="hidden" value="Test"/>""" - """<input name="incparentsf1" type="hidden" value="ON"/>""" - """<img alt="random" border="0" height="13" src="test.png" """ - """usemap="#webqtlmap" width="10"/>""" - """</form>""")) - - def test_create_paragraph(self): - """Test HT.Paragraph method""" - test_p_element = HtmlGenWrapper.create_p_tag(id="smallSize") - par_text = ( - "Mapping using genotype data as " - "a trait will result in infinity LRS at one locus. " - "In order to display the result properly, all LRSs " - "higher than 100 are capped at 100." - ) - self.assertEqual( - str(test_p_element), - """<p id="smallSize"></p>""" - ) - test_p_element.append(HtmlGenWrapper.create_br_tag()) - test_p_element.append(par_text) - self.assertEqual( - str(test_p_element), - """<p id="smallSize"><br/>{}</p>""".format(par_text) - ) - - def test_create_br_tag(self): - """Test HT.BR() method""" - self.assertEqual(str(HtmlGenWrapper.create_br_tag()), - "<br/>") - - def test_create_input_tag(self): - """Test HT.Input method""" - self.assertEqual( - str(HtmlGenWrapper.create_input_tag( - type_="hidden", - name="name", - value="key", - Class="trait trait_")).replace("\n", ""), - ("""<input class="trait trait_" name="name" """ - """type="hidden" value="key"/>""")) - - def test_create_map_tag(self): - """Test HT.Map method""" - self.assertEqual(str(HtmlGenWrapper.create_map_tag( - name="WebqTLImageMap")).replace("\n", ""), - """<map name="WebqTLImageMap"></map>""") - gifmap = HtmlGenWrapper.create_map_tag(name="test") - gifmap.append(HtmlGenWrapper.create_area_tag(shape="rect", - coords='1 2 3', href='#area1')) - gifmap.append(HtmlGenWrapper.create_area_tag(shape="rect", - coords='1 2 3', href='#area2')) - self.assertEqual( - str(gifmap).replace("\n", ""), - ("""<map name="test">""" - """<area coords="1 2 3" """ - """href="#area1" shape="rect"/>""" - """<area coords="1 2 3" href="#area2" shape="rect"/>""" - """</map>""")) - - def test_create_area_tag(self): - """Test HT.Area method""" - self.assertEqual( - str(HtmlGenWrapper.create_area_tag( - shape="rect", - coords="1 2", - href="http://test.com", - title="Some Title")).replace("\n", ""), - ("""<area coords="1 2" href="http://test.com" """ - """shape="rect" title="Some Title"/>""")) - - def test_create_link_tag(self): - """Test HT.HREF method""" - self.assertEqual( - str(HtmlGenWrapper.create_link_tag( - "www.test.com", "test", target="_blank")).replace("\n", ""), - """<a href="www.test.com" target="_blank">test</a>""") diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py deleted file mode 100644 index 9d988597..00000000 --- a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py +++ /dev/null @@ -1,188 +0,0 @@ -# test for wqflask/marker_regression/gemma_mapping.py -import os -import unittest -import random -from unittest import mock -from wqflask.marker_regression.gemma_mapping import run_gemma -from wqflask.marker_regression.gemma_mapping import gen_pheno_txt_file -from wqflask.marker_regression.gemma_mapping import gen_covariates_file -from wqflask.marker_regression.gemma_mapping import parse_loco_output - - -class AttributeSetter: - def __init__(self, obj): - for key, val in obj.items(): - setattr(self, key, val) - - -class MockGroup(AttributeSetter): - def get_samplelist(self, redis_conn): - return None - - -class TestGemmaMapping(unittest.TestCase): - - @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output") - def test_run_gemma_firstrun_set_false(self, mock_parse_loco): - """add tests for gemma function where first run is set to false""" - dataset = AttributeSetter( - {"group": AttributeSetter({"genofile": "genofile.geno"})}) - - output_file = "file1" - mock_parse_loco.return_value = [] - this_trait = AttributeSetter({"name": "t1"}) - - result = run_gemma(this_trait=this_trait, this_dataset=dataset, samples=[], vals=[ - ], covariates="", use_loco=True, first_run=False, output_files=output_file) - - expected_results = ([], "file1") - self.assertEqual(expected_results, result) - - @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img") - @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMAOPTS", "-debug") - @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMA_WRAPPER_COMMAND", "ghc") - @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", - os.path.join(os.path.dirname(__file__), "user/data")) - @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output") - @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files") - @mock.patch("wqflask.marker_regression.gemma_mapping.gen_covariates_file") - @mock.patch("wqflask.marker_regression.run_mapping.random.choice") - @mock.patch("wqflask.marker_regression.gemma_mapping.os") - @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file") - def test_run_gemma_firstrun_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files, mock_parse_loco): - """add tests for run_gemma where first run is set to true""" - this_chromosomes = {} - for i in range(1, 5): - this_chromosomes[f'CH{i}'] = (AttributeSetter({"name": f"CH{i}"})) - chromosomes = AttributeSetter({"chromosomes": lambda cursor: this_chromosomes}) - - dataset_group = MockGroup( - {"name": "GP1", "genofile": "file_geno"}) - dataset = AttributeSetter({"group": dataset_group, "name": "dataset1_name", - "species": AttributeSetter({"chromosomes": chromosomes})}) - trait = AttributeSetter({"name": "trait1"}) - samples = [] - mock_gen_pheno_txt.return_value = None - mock_os.path.isfile.return_value = True - mock_gen_covar.return_value = None - mock_choice.return_value = "R" - mock_flat_files.return_value = os.path.join( - os.path.dirname(__file__), "genotype/bimbam") - mock_parse_loco.return_value = [] - results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[ - ], vals=[], covariates="", use_loco=True) - mock_gen_pheno_txt.assert_called_once() - mock_parse_loco.assert_called_once_with( - dataset, "GP1_GWA_RRRRRR", True) - mock_os.path.isfile.assert_called_once_with( - ('/home/user/imgfile_output.assoc.txt')) - self.assertEqual(results, ([], "GP1_GWA_RRRRRR")) - - @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data") - def test_gen_pheno_txt_file(self): - """add tests for generating pheno txt file""" - with mock.patch("builtins.open", mock.mock_open())as mock_open: - gen_pheno_txt_file( - this_dataset=AttributeSetter({"name": "A"}), - genofile_name="", vals=[ - "x", "w", "q", "we", "R"]) - mock_open.assert_called_once_with( - '/home/user/data/gn2/PHENO_KiAEKlCvM6iGTM9Kh_TAlQ.txt', 'w') - filehandler = mock_open() - values = ["x", "w", "q", "we", "R"] - write_calls = [mock.call('NA\n'), mock.call('w\n'), mock.call( - 'q\n'), mock.call('we\n'), mock.call('R\n')] - - filehandler.write.assert_has_calls(write_calls) - - @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files") - @mock.patch("wqflask.marker_regression.gemma_mapping.create_trait") - @mock.patch("wqflask.marker_regression.gemma_mapping.create_dataset") - def test_gen_covariates_file(self, create_dataset, create_trait, flat_files): - """add tests for generating covariates files""" - covariates = "X1:X2,Y1:Y2,M1:M3,V1:V2" - samplelist = ["X1", "X2", "X3", "X4"] - create_dataset_side_effect = [] - create_trait_side_effect = [] - - for i in range(4): - create_dataset_side_effect.append( - AttributeSetter({"name": f'name_{i}'})) - create_trait_side_effect.append( - AttributeSetter({"data": [f'data_{i}']})) - - create_dataset.side_effect = create_trait_side_effect - create_trait.side_effect = create_trait_side_effect - - group = MockGroup({"name": "group_X", "samplelist": samplelist}) - this_dataset = AttributeSetter({"group": group, "name": "dataset1_name"}) - flat_files.return_value = "Home/Genenetwork" - - with mock.patch("builtins.open", mock.mock_open())as mock_open: - gen_covariates_file(this_dataset=this_dataset, covariates=covariates, - samples=["x1", "x2", "X3"]) - - create_dataset.assert_has_calls( - [mock.call('X2'), mock.call('Y2'), mock.call('M3'), mock.call('V2')]) - mock_calls = [] - trait_names = ["X1", "Y1", "M1", "V1"] - - for i, trait in enumerate(create_trait_side_effect): - mock_calls.append( - mock.call(dataset=trait, name=trait_names[i], cellid=None)) - - create_trait.assert_has_calls(mock_calls) - - flat_files.assert_called_once_with('mapping') - mock_open.assert_called_once_with( - 'Home/Genenetwork/COVAR_npKxIOnq3azWdgYixtd9IQ.txt', 'w') - filehandler = mock_open() - filehandler.write.assert_has_calls([mock.call( - '-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('\n')]) - - @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp") - @mock.patch("wqflask.marker_regression.gemma_mapping.os") - @mock.patch("wqflask.marker_regression.gemma_mapping.json") - def test_parse_loco_outputfile_found(self, mock_json, mock_os): - """add tests for parse loco output file found""" - mock_json.load.return_value = { - "files": [["file_name", "user", "~/file1"], - ["file_name", "user", "~/file2"]] - } - return_file = """X/Y\tM1\t28.457155\tQ\tE\tA\tMMB\t23.3\tW\t0.9\t0.85\t -chr4\tM2\t12\tQ\tE\tMMB\tR\t24\tW\t0.87\t0.5 -Y\tM4\t12\tQ\tE\tMMB\tR\t11.6\tW\t0.21\t0.7 -X\tM5\t12\tQ\tE\tMMB\tR\t21.1\tW\t0.65\t0.6""" - - return_file_2 = """chr\tother\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5\t0.4""" - mock_os.path.isfile.return_value = True - file_to_write = """{"files":["file_1","file_2"]}""" - with mock.patch("builtins.open") as mock_open: - - handles = (mock.mock_open(read_data="gwas").return_value, mock.mock_open( - read_data=return_file).return_value, mock.mock_open(read_data=return_file_2).return_value) - mock_open.side_effect = handles - results = parse_loco_output( - this_dataset={}, gwa_output_filename=".xw/") - expected_results = [ - {'name': 'M1', 'chr': 'X/Y', 'Mb': 2.8457155e-05, 'p_value': 0.85, - 'additive': -11.65, 'lod_score': 0.07058107428570727}, - {'name': 'M2', 'chr': 4, 'Mb': 1.2e-05, 'p_value': 0.5, - 'additive': -12.0, 'lod_score': 0.3010299956639812}, - {'name': 'M4', 'chr': 'Y', 'Mb': 1.2e-05, 'p_value': 0.7, - 'additive': -5.8, 'lod_score': 0.1549019599857432}, - {'name': 'M5', 'chr': 'X', 'Mb': 1.2e-05, 'p_value': 0.6, 'additive': -10.55, 'lod_score': 0.22184874961635637}] - self.assertEqual(expected_results, results) - - @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp") - @mock.patch("wqflask.marker_regression.gemma_mapping.os") - def test_parse_loco_outputfile_not_found(self, mock_os): - """add tests for parse loco output where output file not found""" - - mock_os.path.isfile.return_value = False - file_to_write = """{"files":["file_1","file_2"]}""" - - with mock.patch("builtins.open", mock.mock_open(read_data=file_to_write)) as mock_open: - results = parse_loco_output( - this_dataset={}, gwa_output_filename=".xw/") - self.assertEqual(results, []) diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py deleted file mode 100644 index fd21a825..00000000 --- a/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py +++ /dev/null @@ -1,86 +0,0 @@ -# test for wqflask/marker_regression/plink_mapping.py -import unittest -from unittest import mock -from wqflask.marker_regression.plink_mapping import build_line_list -from wqflask.marker_regression.plink_mapping import get_samples_from_ped_file -from wqflask.marker_regression.plink_mapping import flat_files -from wqflask.marker_regression.plink_mapping import gen_pheno_txt_file_plink -from wqflask.marker_regression.plink_mapping import parse_plink_output - - -class AttributeSetter: - def __init__(self, obj): - for key, val in obj.items(): - setattr(self, key, val) - - -class TestPlinkMapping(unittest.TestCase): - - def test_build_line_list(self): - """test for building line list""" - line_1 = "this is line one test" - irregular_line = " this is an, irregular line " - exp_line1 = ["this", "is", "line", "one", "test"] - - results = build_line_list(irregular_line) - self.assertEqual(exp_line1, build_line_list(line_1)) - self.assertEqual([], build_line_list()) - self.assertEqual(["this", "is", "an,", "irregular", "line"], results) - - @mock.patch("wqflask.marker_regression.plink_mapping.flat_files") - def test_get_samples_from_ped_file(self, mock_flat_files): - """test for getting samples from ped file""" - dataset = AttributeSetter({"group": AttributeSetter({"name": "n_1"})}) - file_sample = """Expected_1\tline test -Expected_2\there - Expected_3\tthree""" - mock_flat_files.return_value = "/home/user/" - with mock.patch("builtins.open", mock.mock_open(read_data=file_sample)) as mock_open: - results = get_samples_from_ped_file(dataset) - mock_flat_files.assert_called_once_with("mapping") - mock_open.assert_called_once_with("/home/user/n_1.ped", "r") - self.assertEqual( - ["Expected_1", "Expected_2", "Expected_3"], results) - - @mock.patch("wqflask.marker_regression.plink_mapping.TMPDIR", "/home/user/data/") - @mock.patch("wqflask.marker_regression.plink_mapping.get_samples_from_ped_file") - def test_gen_pheno_txt_file_plink(self, mock_samples): - """test for getting gen_pheno txt file""" - mock_samples.return_value = ["Expected_1", "Expected_2", "Expected_3"] - - trait = AttributeSetter({"name": "TX"}) - dataset = AttributeSetter({"group": AttributeSetter({"name": "n_1"})}) - vals = ["value=K1", "value=K2", "value=K3"] - with mock.patch("builtins.open", mock.mock_open()) as mock_open: - results = gen_pheno_txt_file_plink(this_trait=trait, dataset=dataset, - vals=vals, pheno_filename="ph_file") - mock_open.assert_called_once_with( - "/home/user/data/ph_file.txt", "wb") - filehandler = mock_open() - calls_expected = [mock.call('FID\tIID\tTX\n'), - mock.call('Expected_1\tExpected_1\tK1\nExpected_2\tExpected_2\tK2\nExpected_3\tExpected_3\tK3\n')] - - filehandler.write.assert_has_calls(calls_expected) - - filehandler.close.assert_called_once() - - @mock.patch("wqflask.marker_regression.plink_mapping.TMPDIR", "/home/user/data/") - @mock.patch("wqflask.marker_regression.plink_mapping.build_line_list") - def test_parse_plink_output(self, mock_line_list): - """test for parsing plink output""" - chromosomes = [0, 34, 110, 89, 123, 23, 2] - species = AttributeSetter( - {"name": "S1", "chromosomes": AttributeSetter({"chromosomes": chromosomes})}) - - fake_file = """0 AACCAT T98.6 0.89\n2 AATA B45 0.3\n121 ACG B56.4 NA""" - - mock_line_list.side_effect = [["0", "AACCAT", "T98.6", "0.89"], [ - "2", "AATA", "B45", "0.3"], ["121", "ACG", "B56.4", "NA"]] - with mock.patch("builtins.open", mock.mock_open(read_data=fake_file)) as mock_open: - parse_results = parse_plink_output( - output_filename="P1_file", species=species) - mock_open.assert_called_once_with( - "/home/user/data/P1_file.qassoc", "rb") - expected = (2, {'AACCAT': 0.89, 'AATA': 0.3}) - - self.assertEqual(parse_results, expected) diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py deleted file mode 100644 index 8b4337ec..00000000 --- a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py +++ /dev/null @@ -1,24 +0,0 @@ -import unittest -from unittest import mock -from wqflask.marker_regression.qtlreaper_mapping import gen_pheno_txt_file - -# issues some methods in genofile object are not defined -# modify samples should equal to vals - - -class TestQtlReaperMapping(unittest.TestCase): - @mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data") - def test_gen_pheno_txt_file(self): - vals = ["V1", "x", "V4", "V3", "x"] - samples = ["S1", "S2", "S3", "S4", "S5"] - trait_filename = "trait_file" - with mock.patch("builtins.open", mock.mock_open())as mock_open: - gen_pheno_txt_file(samples=samples, vals=vals, - trait_filename=trait_filename) - mock_open.assert_called_once_with( - "/home/user/data/gn2/trait_file.txt", "w") - filehandler = mock_open() - write_calls = [mock.call('Trait\t'), mock.call( - 'S1\tS3\tS4\n'), mock.call('T1\t'), mock.call('V1\tV4\tV3')] - - filehandler.write.assert_has_calls(write_calls) diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py deleted file mode 100644 index b4423d8f..00000000 --- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py +++ /dev/null @@ -1,43 +0,0 @@ -import unittest -from unittest import mock -from dataclasses import dataclass - -from wqflask.marker_regression.rqtl_mapping import run_rqtl - -@dataclass -class MockGroup: - name: str - genofile: str - -@dataclass -class MockDataset: - group: MockGroup - -class TestRqtlMapping(unittest.TestCase): - """Tests for functions in rqtl_mapping.py""" - @mock.patch("wqflask.marker_regression.rqtl_mapping.requests.post") - @mock.patch("wqflask.marker_regression.rqtl_mapping.locate") - @mock.patch("wqflask.marker_regression.rqtl_mapping.write_phenotype_file") - def test_run_rqtl_with_perm(self, mock_write_pheno_file, mock_locate, mock_post): - """Test for run_rqtl with permutations > 0""" - dataset_group = MockGroup("GP1", "file_geno") - dataset = MockDataset(dataset_group) - - mock_write_pheno_file.return_value = "pheno_filename" - mock_locate.return_value = "geno_filename" - mock_post.return_value = mock.Mock(ok=True) - mock_post.return_value.json.return_value = {"perm_results": [], - "suggestive": 3, - "significant": 4, - "results" : []} - - results = run_rqtl(trait_name="the_trait", vals=[], samples=[], - dataset=dataset, pair_scan=False, mapping_scale="cM", model="normal", method="hk", - num_perm=5, perm_strata_list=[], do_control="false", control_marker="", - manhattan_plot=True, cofactors="") - - mock_write_pheno_file.assert_called_once() - mock_locate.assert_called_once() - mock_post.assert_called_once() - - self.assertEqual(results, ([], 3, 4, [])) diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py deleted file mode 100644 index 2e1b5810..00000000 --- a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py +++ /dev/null @@ -1,288 +0,0 @@ -import unittest -import datetime -from unittest import mock - -from wqflask.marker_regression.run_mapping import get_genofile_samplelist -from wqflask.marker_regression.run_mapping import geno_db_exists -from wqflask.marker_regression.run_mapping import write_input_for_browser -from wqflask.marker_regression.run_mapping import export_mapping_results -from wqflask.marker_regression.run_mapping import trim_markers_for_figure -from wqflask.marker_regression.run_mapping import get_perm_strata -from wqflask.marker_regression.run_mapping import get_chr_lengths - - -class AttributeSetter: - def __init__(self, obj): - for k, v in obj.items(): - setattr(self, k, v) - - -class MockGroup(AttributeSetter): - - def get_genofiles(self): - return [{"location": "~/genofiles/g1_file", "sample_list": ["S1", "S2", "S3", "S4"]}] - - -class TestRunMapping(unittest.TestCase): - def setUp(self): - - self.group = MockGroup( - {"genofile": "~/genofiles/g1_file", "name": "GP1_", "species": "Human"}) - chromosomes = { - "3": AttributeSetter({ - "name": "C1", - "length": "0.04" - }), - "4": AttributeSetter({ - "name": "C2", - "length": "0.03" - }), - "5": AttributeSetter({ - "name": "C4", - "length": "0.01" - }) - } - self.dataset = AttributeSetter( - {"fullname": "dataset_1", "group": self.group, "type": "ProbeSet"}) - - self.chromosomes = AttributeSetter({"chromosomes": lambda cur: chromosomes}) - self.trait = AttributeSetter( - {"symbol": "IGFI", "chr": "X1", "mb": 123313, "display_name": "Test Name"}) - - def tearDown(self): - self.dataset = AttributeSetter( - {"group": {"location": "~/genofiles/g1_file"}}) - - def test_get_genofile_samplelist(self): - - results_1 = get_genofile_samplelist(self.dataset) - self.assertEqual(results_1, ["S1", "S2", "S3", "S4"]) - self.group.genofile = "~/genofiles/g2_file" - result_2 = get_genofile_samplelist(self.dataset) - self.assertEqual(result_2, []) - - @mock.patch("wqflask.marker_regression.run_mapping.data_set") - def test_if_geno_db_exists(self, mock_data_set): - mock_data_set.create_dataset.side_effect = [ - AttributeSetter({}), Exception()] - results_no_error = geno_db_exists(self.dataset) - results_with_error = geno_db_exists(self.dataset) - - self.assertEqual(mock_data_set.create_dataset.call_count, 2) - self.assertEqual(results_with_error, "False") - self.assertEqual(results_no_error, "True") - - def test_trim_markers_for_figure(self): - - markers = [{ - "name": "MK1", - "chr": "C1", - "cM": "1", - "Mb": "12000", - "genotypes": [], - "dominance":"TT", - "additive":"VA", - "lod_score":0.5 - }, - { - "name": "MK2", - "chr": "C2", - "cM": "15", - "Mb": "10000", - "genotypes": [], - "lod_score":0.7 - }, - { - "name": "MK1", - "chr": "C3", - "cM": "45", - "Mb": "1", - "genotypes": [], - "dominance":"Tt", - "additive":"VE", - "lod_score":1 - }] - - marker_2 = [{ - "name": "MK1", - "chr": "C1", - "cM": "1", - "Mb": "12000", - "genotypes": [], - "dominance":"TT", - "additive":"VA", - "p_wald":4.6 - }] - results = trim_markers_for_figure(markers) - result_2 = trim_markers_for_figure(marker_2) - expected = [ - { - "name": "MK1", - "chr": "C1", - "cM": "1", - "Mb": "12000", - "genotypes": [], - "dominance":"TT", - "additive":"VA", - "lod_score":0.5 - }, - { - "name": "MK1", - "chr": "C3", - "cM": "45", - "Mb": "1", - "genotypes": [], - "dominance":"Tt", - "additive":"VE", - "lod_score":1 - } - - ] - self.assertEqual(results, expected) - self.assertEqual(result_2, marker_2) - - def test_export_mapping_results(self): - """test for exporting mapping results""" - datetime_mock = mock.Mock(wraps=datetime.datetime) - datetime_mock.now.return_value = datetime.datetime( - 2019, 9, 1, 10, 12, 12) - - markers = [{ - "name": "MK1", - "chr": "C1", - "cM": "1", - "Mb": "12000", - "genotypes": [], - "dominance":"TT", - "additive":"VA", - "lod_score":3 - }, - { - "name": "MK2", - "chr": "C2", - "cM": "15", - "Mb": "10000", - "genotypes": [], - "lod_score":7 - }, - { - "name": "MK1", - "chr": "C3", - "cM": "45", - "Mb": "1", - "genotypes": [], - "dominance":"Tt", - "additive":"VE", - "lod_score":7 - }] - - with mock.patch("builtins.open", mock.mock_open()) as mock_open: - - with mock.patch("wqflask.marker_regression.run_mapping.datetime.datetime", new=datetime_mock): - export_mapping_results(dataset=self.dataset, trait=self.trait, markers=markers, - results_path="~/results", mapping_method="gemma", mapping_scale="physic", - score_type="-logP", transform="qnorm", - covariates="Dataset1:Trait1,Dataset2:Trait2", - n_samples="100", vals_hash="") - - write_calls = [ - mock.call('Time/Date: 09/01/19 / 10:12:12\n'), - mock.call('Population: Human GP1_\n'), mock.call( - 'Data Set: dataset_1\n'), - mock.call('Trait: Test Name\n'), - mock.call('Trait Hash: \n'), - mock.call('N Samples: 100\n'), - mock.call('Mapping Tool: gemma\n'), - mock.call('Transform - Quantile Normalized\n'), - mock.call('Gene Symbol: IGFI\n'), mock.call( - 'Location: X1 @ 123313 Mb\n'), - mock.call('Cofactors (dataset - trait):\n'), - mock.call('Trait1 - Dataset1\n'), - mock.call('Trait2 - Dataset2\n'), - mock.call('\n'), mock.call('Name,Chr,'), - mock.call('Mb,-logP'), - mock.call(',Additive'), mock.call(',Dominance'), - mock.call('\n'), mock.call('MK1,C1,'), - mock.call('12000,'), mock.call('3'), - mock.call(',VA'), mock.call(',TT'), - mock.call('\n'), mock.call('MK2,C2,'), - mock.call('10000,'), mock.call('7'), - mock.call('\n'), mock.call('MK1,C3,'), - mock.call('1,'), mock.call('7'), - mock.call(',VE'), mock.call(',Tt') - ] - mock_open.assert_called_once_with("~/results", "w+") - filehandler = mock_open() - filehandler.write.assert_has_calls(write_calls) - - @mock.patch("wqflask.marker_regression.run_mapping.random.choice") - def test_write_input_for_browser(self, mock_choice): - """test for writing input for browser""" - mock_choice.side_effect = ["F", "i", "l", "e", "s", "x"] - with mock.patch("builtins.open", mock.mock_open()) as mock_open: - expected = ['GP1__Filesx_GWAS', 'GP1__Filesx_ANNOT'] - - results = write_input_for_browser( - this_dataset=self.dataset, gwas_results={}, annotations={}) - self.assertEqual(results, expected) - - def test_get_perm_strata(self): - categorical_vars = ["C1", "C2", "W1"] - used_samples = ["S1", "S2"] - sample_list = AttributeSetter({"sample_attribute_values": { - "S1": { - "c1": "c1_value", - "c2": "c2_value", - "w1": "w1_value" - }, - "S2": { - "w1": "w2_value", - "w2": "w2_value" - }, - "S3": { - - "c1": "c1_value", - "c2": "c2_value" - }, - }}) - results = get_perm_strata(this_trait={}, sample_list=sample_list, - categorical_vars=categorical_vars, used_samples=used_samples) - self.assertEqual(results, [1, 1]) - - def test_get_chr_length(self): - """test for getting chromosome length""" - cursor = mock.MagicMock() - chromosomes = AttributeSetter({"chromosomes": self.chromosomes}) - dataset = AttributeSetter({"species": chromosomes}) - results = get_chr_lengths( - mapping_scale="physic", mapping_method="reaper", dataset=dataset, qtl_results=[]) - chr_lengths = [] - for key, chromo in self.chromosomes.chromosomes(cursor).items(): - chr_lengths.append({"chr": chromo.name, "size": chromo.length}) - - self.assertEqual(chr_lengths, results) - - qtl_results = [{ - "chr": "16", - "cM": "0.2" - }, - { - "chr": "12", - "cM": "0.5" - }, - { - "chr": "18", - "cM": "0.1" - }, - { - "chr": "22", - "cM": "0.4" - }, - ] - - result_with_other_mapping_scale = get_chr_lengths( - mapping_scale="other", mapping_method="reaper", dataset=dataset, qtl_results=qtl_results) - expected_value = [{'chr': '1', 'size': '0'}, { - 'chr': '16', 'size': '500000.0'}, {'chr': '18', 'size': '400000.0'}] - - self.assertEqual(result_with_other_mapping_scale, expected_value) diff --git a/wqflask/tests/unit/wqflask/show_trait/__init__.py b/wqflask/tests/unit/wqflask/show_trait/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/wqflask/show_trait/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/unit/wqflask/show_trait/test_export_trait_data.py deleted file mode 100644 index 8aa3ffd5..00000000 --- a/wqflask/tests/unit/wqflask/show_trait/test_export_trait_data.py +++ /dev/null @@ -1,151 +0,0 @@ -import datetime -import unittest -from unittest import mock -from wqflask.show_trait.export_trait_data import dict_to_sorted_list -from wqflask.show_trait.export_trait_data import cmp_samples -from wqflask.show_trait.export_trait_data import export_sample_table -from wqflask.show_trait.export_trait_data import get_export_metadata - - -class AttributesSetter: - def __init__(self, obj): - for key, value in obj.items(): - setattr(self, key, value) - - -class TestExportTraits(unittest.TestCase): - """Test methods for exporting traits and metadata""" - - @mock.patch("wqflask.show_trait.export_trait_data.datetime") - @mock.patch("wqflask.show_trait.export_trait_data.create_trait") - @mock.patch("wqflask.show_trait.export_trait_data.data_set") - def test_get_export_metadata(self, data_mock, trait_mock, date_mock): - """test for exporting metadata with dataset.type=Publish""" - mock_dataset = AttributesSetter({"type": "Publish", - "name": "HC_M2_0606_P", - "dataset_name": "HC_M2_0606_P"}) - - mock_dataset.group = AttributesSetter({"name": "C"}) - data_mock.create_dataset.return_value = mock_dataset - - trait_data = { - "symbol": "Nr3c1", - "description_display": "nuclear receptor subfamily 3,group C, member 1 (glucocorticoid receptor); distal 3' UTR", - "title": "Trait_1 title", - - "authors": "XL_1", - "journal": "" - - } - - date_mock.datetime.now.return_value = datetime.datetime( - 2022, 8, 8, 19, 2, 31, 628813) - trait_mock.return_value = AttributesSetter(trait_data) - - results = get_export_metadata({ - "trait_id": "1460303_at", - "trait_display_name": "1460303_at", - "dataset": "HC_M2_0606_P", - "group": "BXD", - }) - - expected = [["Phenotype ID:", "1460303_at"], - ["Phenotype URL: ", "http://genenetwork.org/show_trait?trait_id=1460303_at&dataset=HC_M2_0606_P"], - ["Group: ", "C"], - ["Phenotype: ", - 'nuclear receptor subfamily 3","group C"," member 1 (glucocorticoid receptor); distal 3\' UTR'], - ["Authors: ", "XL_1"], - ["Title: ", "Trait_1 title"], - ["Journal: ", "N/A"], - ["Dataset Link: ", "http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=HC_M2_0606_P"], - ["Export Date: ", "August 08, 2022"], - ["Export Time: ", "19:02 GMT"]] - - self.assertEqual(results, expected) - - def test_dict_to_sortedlist(self): - """test for conversion of dict to sorted list""" - sample1 = { - "other": "exp1", - "name": "exp2" - } - sample2 = { - "se": 1, - "num_cases": 4, - "value": 6, - "name": 3 - - } - rever = { - "name": 3, - "value": 6, - "num_cases": 4, - "se": 1 - } - oneItem = { - "item1": "one" - } - - self.assertEqual(["exp2", "exp1"], dict_to_sorted_list(sample1)) - self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(sample2)) - self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(rever)) - self.assertEqual(["one"], dict_to_sorted_list(oneItem)) - """test that the func returns the values not the keys""" - self.assertFalse(["other", "name"] == dict_to_sorted_list(sample1)) - - def test_cmp_samples(self): - """test for comparing samples function""" - sampleA = [ - [ - ("value", "other"), - ("name", "test_name") - ] - ] - sampleB = [ - [ - ("value", "other"), - ("unknown", "test_name") - ] - ] - sampleC = [ - [("other", "value"), - ("name", "value") - ], - [ - ("name", "value"), - ("value", "name") - ], - [ - ("other", "value"), - ("name", "value" - )], - [ - ("name", "name1"), - ("se", "valuex") - ], - [( - "value", "name1"), - ("se", "valuex") - ], - [( - "other", "name1"), - ("se", "valuex" - ) - ], - [( - "name", "name_val"), - ("num_cases", "num_val") - ], - [( - "other_a", "val_a"), - ("other_b", "val" - ) - ] - ] - results = [cmp_samples(val[0], val[1]) for val in sampleA] - resultB = [cmp_samples(val[0], val[1]) for val in sampleB] - resultC = [cmp_samples(val[0], val[1]) for val in sampleC] - - self.assertEqual(1, *results) - self.assertEqual(-1, *resultB) - self.assertEqual([1, -1, 1, -1, -1, 1, -1, -1], resultC) diff --git a/wqflask/tests/unit/wqflask/show_trait/test_get_max_digits.py b/wqflask/tests/unit/wqflask/show_trait/test_get_max_digits.py deleted file mode 100644 index da10b13c..00000000 --- a/wqflask/tests/unit/wqflask/show_trait/test_get_max_digits.py +++ /dev/null @@ -1,15 +0,0 @@ -import pytest -import unittest - -from wqflask.show_trait.show_trait import get_max_digits - -@unittest.skip("Too complicated") -@pytest.mark.parametrize( - "trait_vals,expected", - ((( - (0, 1345, 92, 734), - (234253, 33, 153, 5352), - (3542, 24, 135)), - [3, 5, 3]),)) -def test_get_max_digits(trait_vals, expected): - assert get_max_digits(trait_vals) == expected diff --git a/wqflask/tests/unit/wqflask/snp_browser/__init__.py b/wqflask/tests/unit/wqflask/snp_browser/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/wqflask/snp_browser/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py deleted file mode 100644 index a09d1538..00000000 --- a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py +++ /dev/null @@ -1,206 +0,0 @@ -import unittest -from unittest import mock -from wqflask import app -from wqflask.snp_browser.snp_browser import get_gene_id -from wqflask.snp_browser.snp_browser import get_gene_id_name_dict -from wqflask.snp_browser.snp_browser import check_if_in_gene -from wqflask.snp_browser.snp_browser import get_browser_sample_lists -from wqflask.snp_browser.snp_browser import get_header_list - - -class TestSnpBrowser(unittest.TestCase): - def setUp(self): - self.app_context = app.app_context() - self.app_context.push() - - def tearDown(self): - self.app_context.pop() - - def test_get_header_list(self): - empty_columns = { - "snp_source": "false", - "conservation_score": "true", - "gene_name": "false", - "transcript": "false", - "exon": "false", - "domain_2": "true", - "function": "false", - "function_details": "true", - } - strains = {"mouse": ["S1", "S2", "S3", "S4", "S5"], "rat": []} - expected_results = ( - [ - [ - "Index", - "SNP ID", - "Chr", - "Mb", - "Alleles", - "ConScore", - "Domain 1", - "Domain 2", - "Details", - ], - ["S1", "S2", "S3", "S4", "S5"], - ], - 5, - [ - "index", - "snp_name", - "chr", - "mb_formatted", - "alleles", - "conservation_score", - "domain_1", - "domain_2", - "function_details", - "S1", - "S2", - "S3", - "S4", - "S5", - ], - ) - - results_with_snp = get_header_list( - variant_type="SNP", - strains=strains, - species="Mouse", - empty_columns=empty_columns, - ) - results_with_indel = get_header_list( - variant_type="InDel", strains=strains, species="rat", empty_columns=[] - ) - expected_results_with_indel = ( - [ - "Index", - "ID", - "Type", - "InDel Chr", - "Mb Start", - "Mb End", - "Strand", - "Size", - "Sequence", - "Source", - ], - 0, - [ - "index", - "indel_name", - "indel_type", - "indel_chr", - "indel_mb_s", - "indel_mb_e", - "indel_strand", - "indel_size", - "indel_sequence", - "source_name", - ], - ) - - self.assertEqual(expected_results, results_with_snp) - self.assertEqual(expected_results_with_indel, results_with_indel) - - @mock.patch("wqflask.snp_browser.snp_browser.database_connection") - def test_get_gene_id(self, mock_db): - db_query_value = ( - "SELECT geneId FROM GeneList WHERE " "SpeciesId = %s AND geneSymbol = %s" - ) - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - with conn.cursor() as cursor: - cursor.fetchone.return_value = ( - ("517d729f-aa13-4413" "-a885-40a3f7ff768a"), - ) - - results = get_gene_id( - species_id="c9c0f59e-1259-4cba-91e6-831ef1a99c83", gene_name="INSR" - ) - cursor.execute.assert_called_once_with( - db_query_value, ("c9c0f59e-1259-4cba-91e6-831ef1a99c83", "INSR") - ) - self.assertEqual(results, "517d729f-aa13-4413-a885-40a3f7ff768a") - - @mock.patch("wqflask.snp_browser.snp_browser.database_connection") - def test_gene_id_name_dict(self, mock_db): - no_gene_names = [] - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - with conn.cursor() as cursor: - cursor.fetchall.side_effect = [ - [], - [ - ("fsdf43-fseferger-f22", "GH1"), - ("1sdf43-fsewferger-f22", "GH2"), - ("fwdj43-fstferger-f22", "GH3"), - ], - ] - self.assertEqual( - "", - get_gene_id_name_dict( - species_id="fregb343bui43g4", gene_name_list=no_gene_names - ), - ) - gene_name_list = ["GH1", "GH2", "GH3"] - no_results = get_gene_id_name_dict( - species_id="ret3-32rf32", gene_name_list=gene_name_list - ) - results_found = get_gene_id_name_dict( - species_id="ret3-32rf32", gene_name_list=gene_name_list - ) - expected_found = { - "GH1": "fsdf43-fseferger-f22", - "GH2": "1sdf43-fsewferger-f22", - "GH3": "fwdj43-fstferger-f22", - } - db_query_value = ( - "SELECT geneId, geneSymbol FROM GeneList WHERE " - "SpeciesId = %s AND geneSymbol in (%s, %s, %s)" - ) - cursor.execute.assert_called_with( - db_query_value, ("ret3-32rf32", "GH1", "GH2", "GH3") - ) - self.assertEqual(results_found, expected_found) - self.assertEqual(no_results, {}) - - @mock.patch("wqflask.snp_browser.snp_browser.database_connection") - def test_check_if_in_gene(self, mock_db): - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - with conn.cursor() as cursor: - cursor.fetchone.side_effect = [("fsdf-232sdf-sdf", "GHA"), ""] - results_found = check_if_in_gene( - species_id="517d729f-aa13-4413-a885-40a3f7ff768a", chr_="CH1", mb=12.09 - ) - self.assertEqual(results_found, ["fsdf-232sdf-sdf", "GHA"]) - db_query_value = ( - "SELECT geneId, geneSymbol FROM GeneList " - "WHERE SpeciesId = %s AND chromosome = %s " - "AND (txStart < %s AND txEnd > %s)" - ) - gene_not_found = check_if_in_gene( - species_id="517d729f-aa13-4413-a885-40a3f7ff768a", chr_="CH1", mb=12.09 - ) - cursor.execute.assert_has_calls( - [ - mock.call( - db_query_value, - ("517d729f-aa13-4413-a885-40a3f7ff768a", "CH1", 12.09, 12.09), - ), - mock.call( - db_query_value, - ("517d729f-aa13-4413-a885-40a3f7ff768a", "CH1", 12.09, 12.09), - ), - ] - ) - self.assertEqual(gene_not_found, "") - - @mock.patch("wqflask.snp_browser.snp_browser.database_connection") - def test_get_browser_sample_lists(self, mock_db): - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - with conn.cursor() as cursor: - cursor.execute.return_value.fetchall.return_value = [] - results = get_browser_sample_lists(species_id="12") - self.assertEqual(results, {"mouse": [], "rat": []}) diff --git a/wqflask/tests/unit/wqflask/test_collect.py b/wqflask/tests/unit/wqflask/test_collect.py deleted file mode 100644 index 4e99de7f..00000000 --- a/wqflask/tests/unit/wqflask/test_collect.py +++ /dev/null @@ -1,75 +0,0 @@ -"""Test cases for some methods in collect.py""" - -import unittest -from unittest import mock - -from flask import Flask -from wqflask.collect import process_traits - -app = Flask(__name__) - - -class MockSession: - """Helper class for mocking wqflask.collect.g.user_session.logged_in""" - - def __init__(self, is_logged_in=False): - self.is_logged_in = is_logged_in - - @property - def logged_in(self): - return self.is_logged_in - - -class MockFlaskG: - """Helper class for mocking wqflask.collect.g.user_session""" - - def __init__(self, is_logged_in=False): - self.is_logged_in = is_logged_in - - @property - def user_session(self): - if self.is_logged_in: - return MockSession(is_logged_in=True) - return MockSession() - - -class TestCollect(unittest.TestCase): - - def setUp(self): - self.app_context = app.app_context() - self.app_context.push() - - def tearDown(self): - self.app_context.pop() - - @mock.patch("wqflask.collect.g", MockFlaskG()) - def test_process_traits_with_bytestring(self): - """ - Test that the correct traits are returned when the user is logged - out and bytes are used. - """ - self.assertEqual(sorted(process_traits( - b'1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,' - b'1452447_at:HC_M2_0606_P:eeece8fceb67072debea,' - b'1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,' - b'1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5')), - sorted(['1429252_at:HC_M2_0606_P', - '1451401_a_at:HC_M2_0606_P', - '1452447_at:HC_M2_0606_P', - '1452452_at:HC_M2_0606_P'])) - - @mock.patch("wqflask.collect.g", MockFlaskG()) - def test_process_traits_with_normal_string(self): - """ - Test that the correct traits are returned when the user is logged - out and a normal string is used. - """ - self.assertEqual(sorted(process_traits( - '1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,' - '1452447_at:HC_M2_0606_P:eeece8fceb67072debea,' - '1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,' - '1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5')), - sorted(['1429252_at:HC_M2_0606_P', - '1451401_a_at:HC_M2_0606_P', - '1452447_at:HC_M2_0606_P', - '1452452_at:HC_M2_0606_P'])) diff --git a/wqflask/tests/unit/wqflask/test_pbkdf2.py b/wqflask/tests/unit/wqflask/test_pbkdf2.py deleted file mode 100644 index 7ad6c83e..00000000 --- a/wqflask/tests/unit/wqflask/test_pbkdf2.py +++ /dev/null @@ -1,61 +0,0 @@ -"""Test cases pbkdf2""" - -import unittest -from wqflask.pbkdf2 import pbkdf2_hex - - -class TestPbkdf2(unittest.TestCase): - def test_pbkdf2_hex(self): - """ - Test pbkdf2_hex function - """ - - for password, salt, iterations, keylen, expected_value in [ - ('password', b'salt', 1, 20, - '0c60c80f961f0e71f3a9b524af6012062fe037a6'), - ('password', b'salt', 2, 20, - 'ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957'), - ('password', b'salt', 4096, 20, - '4b007901b765489abead49d926f721d065a429c1'), - ('passwordPASSWORDpassword', - b'saltSALTsaltSALTsaltSALTsaltSALTsalt', - 4096, 25, - '3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038'), - ('pass\x00word', b'sa\x00lt', 4096, 16, - '56fa6aa75548099dcc37d7f03425e0c3'), - ('password', b'ATHENA.MIT.EDUraeburn', 1, 16, - 'cdedb5281bb2f801565a1122b2563515'), - ('password', b'ATHENA.MIT.EDUraeburn', 1, 32, - ('cdedb5281bb2f80' - '1565a1122b256351' - '50ad1f7a04bb9f3a33' - '3ecc0e2e1f70837')), - ('password', b'ATHENA.MIT.EDUraeburn', 2, 16, - '01dbee7f4a9e243e988b62c73cda935d'), - ('password', b'ATHENA.MIT.EDUraeburn', 2, 32, - ('01dbee7f4a9e243e9' - '88b62c73cda935da05' - '378b93244ec8f48a99' - 'e61ad799d86')), - ('password', b'ATHENA.MIT.EDUraeburn', 1200, 32, - ('5c08eb61fdf71e' - '4e4ec3cf6ba1f55' - '12ba7e52ddbc5e51' - '42f708a31e2e62b1e13')), - ('X' * 64, b'pass phrase equals block size', 1200, 32, - ('139c30c0966bc32ba' - '55fdbf212530ac9c5' - 'ec59f1a452f5cc9ad' - '940fea0598ed1')), - ('X' * 65, b'pass phrase exceeds block size', 1200, 32, - ('9ccad6d468770cd' - '51b10e6a68721be6' - '11a8b4d282601db3' - 'b36be9246915ec82a')) - ]: - self.assertEqual( - pbkdf2_hex(data=password, - salt=salt, - iterations=iterations, - keylen=keylen), - expected_value) diff --git a/wqflask/tests/unit/wqflask/test_resource_manager.py b/wqflask/tests/unit/wqflask/test_resource_manager.py deleted file mode 100644 index f4335425..00000000 --- a/wqflask/tests/unit/wqflask/test_resource_manager.py +++ /dev/null @@ -1,94 +0,0 @@ -"""Test cases for wqflask/resource_manager.py""" -import json -import unittest - -from unittest import mock -from gn3.authentication import get_user_membership -from gn3.authentication import get_highest_user_access_role -from gn3.authentication import DataRole -from gn3.authentication import AdminRole - - -class TestGetUserMembership(unittest.TestCase): - """Test cases for `get_user_membership`""" - - def setUp(self): - conn = mock.MagicMock() - conn.hgetall.return_value = { - '7fa95d07-0e2d-4bc5-b47c-448fdc1260b2': ( - '{"name": "editors", ' - '"admins": ["8ad942fe-490d-453e-bd37-56f252e41604", "rand"], ' - '"members": ["8ad942fe-490d-453e-bd37-56f252e41603", ' - '"rand"], ' - '"changed_timestamp": "Oct 06 2021 06:39PM", ' - '"created_timestamp": "Oct 06 2021 06:39PM"}')} - self.conn = conn - - def test_user_is_group_member_only(self): - """Test that a user is only a group member""" - self.assertEqual( - get_user_membership( - conn=self.conn, - user_id="8ad942fe-490d-453e-bd37-56f252e41603", - group_id="7fa95d07-0e2d-4bc5-b47c-448fdc1260b2"), - {"member": True, - "admin": False}) - - def test_user_is_group_admin_only(self): - """Test that a user is a group admin only""" - self.assertEqual( - get_user_membership( - conn=self.conn, - user_id="8ad942fe-490d-453e-bd37-56f252e41604", - group_id="7fa95d07-0e2d-4bc5-b47c-448fdc1260b2"), - {"member": False, - "admin": True}) - - def test_user_is_both_group_member_and_admin(self): - """Test that a user is both an admin and member of a group""" - self.assertEqual( - get_user_membership( - conn=self.conn, - user_id="rand", - group_id="7fa95d07-0e2d-4bc5-b47c-448fdc1260b2"), - {"member": True, - "admin": True}) - - -class TestCheckUserAccessRole(unittest.TestCase): - """Test cases for `get_highest_user_access_role`""" - - @mock.patch("wqflask.resource_manager.requests.get") - def test_edit_access(self, requests_mock): - """Test that the right access roles are set""" - response = mock.PropertyMock(return_value=json.dumps( - { - 'data': ['no-access', 'view', 'edit', ], - 'metadata': ['no-access', 'view', 'edit', ], - 'admin': ['not-admin', 'edit-access', ], - } - )) - type(requests_mock.return_value).content = response - self.assertEqual(get_highest_user_access_role( - resource_id="0196d92e1665091f202f", - user_id="8ad942fe-490d-453e-bd37"), - {"data": DataRole.EDIT, - "metadata": DataRole.EDIT, - "admin": AdminRole.EDIT_ACCESS}) - - @mock.patch("wqflask.resource_manager.requests.get") - def test_no_access(self, requests_mock): - response = mock.PropertyMock(return_value=json.dumps( - { - 'data': ['no-access', ], - 'metadata': ['no-access', ], - 'admin': ['not-admin', ], - } - )) - type(requests_mock.return_value).content = response - self.assertEqual(get_highest_user_access_role( - resource_id="0196d92e1665091f202f", - user_id=""), - {"data": DataRole.NO_ACCESS, - "metadata": DataRole.NO_ACCESS, - "admin": AdminRole.NOT_ADMIN}) diff --git a/wqflask/tests/unit/wqflask/test_server_side.py b/wqflask/tests/unit/wqflask/test_server_side.py deleted file mode 100644 index be7ca2df..00000000 --- a/wqflask/tests/unit/wqflask/test_server_side.py +++ /dev/null @@ -1,34 +0,0 @@ -import unittest - -from wqflask.server_side import ServerSideTable - - -class TestServerSideTableTests(unittest.TestCase): - """ - Test the ServerSideTable class - - test table: - first, second, third - 'd', 4, 'zz' - 'b', 2, 'aa' - 'c', 1, 'ss' - """ - - def test_get_page(self): - rows_count = 3 - table_rows = [ - {'first': 'd', 'second': 4, 'third': 'zz'}, - {'first': 'b', 'second': 2, 'third': 'aa'}, - {'first': 'c', 'second': 1, 'third': 'ss'}, - ] - headers = ['first', 'second', 'third'] - request_args = {'sEcho': '1', 'iSortCol_0': '1', 'iSortingCols': '1', - 'sSortDir_0': 'asc', 'iDisplayStart': '0', 'iDisplayLength': '3'} - - test_page = ServerSideTable( - rows_count, table_rows, headers, request_args).get_page() - self.assertEqual(test_page['sEcho'], '1') - self.assertEqual(test_page['iTotalRecords'], 'nan') - self.assertEqual(test_page['iTotalDisplayRecords'], '3') - self.assertEqual(test_page['data'], [{'first': 'b', 'second': 2, 'third': 'aa'}, { - 'first': 'c', 'second': 1, 'third': 'ss'}, {'first': 'd', 'second': 4, 'third': 'zz'}]) diff --git a/wqflask/tests/unit/wqflask/test_user_login.py b/wqflask/tests/unit/wqflask/test_user_login.py deleted file mode 100644 index 61cd9ab9..00000000 --- a/wqflask/tests/unit/wqflask/test_user_login.py +++ /dev/null @@ -1,21 +0,0 @@ -"""Test cases for some methods in login.py""" - -import unittest -from wqflask.user_login import encode_password - - -class TestUserLogin(unittest.TestCase): - def test_encode_password(self): - """ - Test encode password - """ - pass_gen_fields = { - "salt": "salt", - "hashfunc": "sha1", - "iterations": 4096, - "keylength": 20, - } - self.assertEqual( - encode_password(pass_gen_fields, - "password").get("password"), - '4b007901b765489abead49d926f721d065a429c1') diff --git a/wqflask/tests/unit/wqflask/test_user_session.py b/wqflask/tests/unit/wqflask/test_user_session.py deleted file mode 100644 index ebb0334a..00000000 --- a/wqflask/tests/unit/wqflask/test_user_session.py +++ /dev/null @@ -1,15 +0,0 @@ -"""Test cases for some methods in user_session.py""" - -import unittest -from wqflask.user_session import verify_cookie - - -class TestUserSession(unittest.TestCase): - def test_verify_cookie(self): - """ - Test cookie verification - """ - self.assertEqual( - "3f4c1dbf-5b56-4260-87d6-f35445bda37e", - verify_cookie(("3f4c1dbf-5b56-4260-87d6-" - "f35445bda37e:af4fcf5eace9e7c864ce"))) diff --git a/wqflask/tests/unit/wqflask/wgcna/__init__.py b/wqflask/tests/unit/wqflask/wgcna/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/wqflask/tests/unit/wqflask/wgcna/__init__.py +++ /dev/null diff --git a/wqflask/tests/unit/wqflask/wgcna/test_wgcna.py b/wqflask/tests/unit/wqflask/wgcna/test_wgcna.py deleted file mode 100644 index 8e947e2f..00000000 --- a/wqflask/tests/unit/wqflask/wgcna/test_wgcna.py +++ /dev/null @@ -1,50 +0,0 @@ - -"""module contains for processing gn3 wgcna data""" -from unittest import TestCase - -from wqflask.wgcna.gn3_wgcna import process_wgcna_data - - -class DataProcessingTests(TestCase): - """class contains data processing tests""" - - def test_data_processing(self): - """test for parsing data for datatable""" - output = { - "input": { - "sample_names": ["BXD1", "BXD2", "BXD3", "BXD4", "BXD5", "BXD6"], - - }, - "output": { - "ModEigens": { - "MEturquoise": [ - 0.0646677768085351, - 0.137200224277058, - 0.63451113720732, - -0.544002665501479, - -0.489487590361863, - 0.197111117570427 - ], - "MEgrey": [ - 0.213, - 0.214, - 0.3141, - -0.545, - -0.423, - 0.156, - ] - }}} - - row_data = [['BXD1', 0.065, 0.213], - ['BXD2', 0.137, 0.214], - ['BXD3', 0.635, 0.314], - ['BXD4', -0.544, -0.545], - ['BXD5', -0.489, -0.423], - ['BXD6', 0.197, 0.156]] - - expected_results = { - "col_names": ["sample_names", "MEturquoise", "MEgrey"], - "mod_dataset": row_data - } - - self.assertEqual(process_wgcna_data(output), expected_results) diff --git a/wqflask/tests/wqflask/show_trait/testSampleList.py b/wqflask/tests/wqflask/show_trait/testSampleList.py deleted file mode 100644 index 305586ce..00000000 --- a/wqflask/tests/wqflask/show_trait/testSampleList.py +++ /dev/null @@ -1,17 +0,0 @@ -import unittest -import re -from unittest import mock -from wqflask.show_trait.SampleList import natural_sort - - -class TestSampleList(unittest.TestCase): - def test_natural_sort(self): - "Sort the list into natural alphanumeric order." - - characters_list = ["z", "f", "q", "s", "t", "a", "g"] - names_list = ["temp1", "publish", "Sample", "Dataset"] - sorted_list_a = natural_sort(characters_list) - sorted_list_b = natural_sort(names_list) - self.assertEqual(sorted_list_a, ["a", "f", "g", "q", "s", "t", "z"]) - self.assertEqual( - sorted_list_b, ["Dataset", "Sample", "publish", "temp1"]) diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py deleted file mode 100644 index 1291037f..00000000 --- a/wqflask/tests/wqflask/show_trait/test_show_trait.py +++ /dev/null @@ -1,255 +0,0 @@ -"""test for wqflask/show_trait/test_show_trait.py""" -import unittest -import pytest -from unittest import mock -from wqflask.show_trait.show_trait import check_if_attr_exists -from wqflask.show_trait.show_trait import get_ncbi_summary -from wqflask.show_trait.show_trait import has_num_cases -from wqflask.show_trait.show_trait import get_table_widths -from wqflask.show_trait.show_trait import get_categorical_variables -from wqflask.show_trait.show_trait import get_trait_units -from wqflask.show_trait.show_trait import get_nearest_marker -from wqflask.show_trait.show_trait import get_genotype_scales -from wqflask.show_trait.show_trait import get_scales_from_genofile - - -class TraitObject: - def __init__(self, obj): - self.distinct_values = [] - self.id = "" - for key, value in obj.items(): - setattr(self, key, value) - self.id += str(value) - - -@pytest.mark.parametrize( - ('trait', 'id_type', 'expected'), - ( - (TraitObject({"id_type": "id"}), "id_type", True), - (TraitObject({"sample_name": ['samp1']}), "id_type", False), - (TraitObject({"sample": ""}), "sample", False), - (TraitObject({"group": None}), "group", False), - (TraitObject({}), "any", False) - ), -) -def test_check_if_attr_exists(trait, id_type, expected): - """"test check_if_attr_exists""" - assert check_if_attr_exists(trait, id_type) == expected - - -def test_get_ncbi_summary_request(mocker): - trait = TraitObject({"geneid": "id"}) - mocker.patch("wqflask.show_trait.show_trait.check_if_attr_exists", - return_value=True) - mock_get = mocker.patch( - "wqflask.show_trait.show_trait.requests.get", - return_value=TraitObject({"content": """{ - "result":{ - "id":{ - "summary":"this is a summary of the geneid" - } - } - } - """})) - assert get_ncbi_summary(trait) == "this is a summary of the geneid" - mock_get.assert_called_once_with( - "http://eutils.ncbi.nlm.nih.gov/entrez/" - "eutils/esummary.fcgi?db=gene&id=" - f"{trait.geneid}&retmode=json" - ) - mock_get.side_effect = Exception("an error occurred") - assert get_ncbi_summary(trait) == None - - -class TestTraits(unittest.TestCase): - def test_hash_num_cases_is_probeset(self): - """test for hash num_cases with dataset.type set to Probeset""" - create_dataset = TraitObject({"type": "ProbeSet"}) - create_trait = TraitObject({"dataset": create_dataset}) - self.assertFalse(has_num_cases(create_trait)) - - def test_hash_num_cases_no_probeset(self): - """test for hash num cases with dataset.type not Probeset""" - create_dataset = TraitObject({"type": "Temp"}) - construct_data = { - "nm1": TraitObject({"num_cases": False}), - "nm2": TraitObject({"num_cases": True}), - "nm3": TraitObject({"num_cases": False}) - } - construct_data2 = { - "nm1": TraitObject({"num_cases": False}), - "nm2": TraitObject({"num_cases": False}), - "nm3": TraitObject({"num_cases": False}) - } - create_trait = TraitObject( - {"dataset": create_dataset, "data": construct_data}) - create_trait2 = TraitObject( - {"dataset": create_dataset, "data": construct_data2}) - - results = has_num_cases(create_trait) - self.assertTrue(has_num_cases(create_trait)) - self.assertFalse(has_num_cases(create_trait2)) - - def test_get_table_widths(self): - """test for getting table widths""" - sample_groups = [TraitObject({'se_exists': True, "attributes": ["attr1", "attr2", "attr3"]} - ), TraitObject( - {"se_exists": False, "attributes": ["at1", "at2"] - })] - - results_with_numcase = get_table_widths(sample_groups, True) - result_no_numcase = get_table_widths(sample_groups, False) - - results_one_sample = get_table_widths( - [TraitObject({"se_exists": True, "attributes": []})], True) - expected_with_numcase = (450, 645) - expected_no_numcase = (450, 644) - expected_one_sample = (250, 381) - self.assertEqual(results_with_numcase, expected_with_numcase) - self.assertEqual(result_no_numcase, expected_no_numcase) - self.assertEqual(results_one_sample, - expected_one_sample) - - def test_get_categorical_variables_no_sample_attributes(self): - """test for getting categorical variable names with no samples""" - trait = TraitObject({}) - sample_list = TraitObject({"se_exists": True, "attributes": []}) - self.assertEqual(get_categorical_variables(trait, sample_list), []) - - def test_get_categorical_variables_with_sample_attributes(self): - """test for getting categorical variable names with no samples""" - this_trait = TraitObject({"data": { - "Gene1": TraitObject({"extra_attributes": {"ex1": "ex1value"}}), - "Gene2": TraitObject({"extra_attributes": {"ex2": "ex2value"}}), - "Gene3": TraitObject({"extra_attributes": {"ex3": "ex3value"}}) - }}) - sample_list = TraitObject({"attributes": { - "sample_attribute_1": TraitObject({"name": "ex1"}), - "sample_attribute_2": TraitObject({"name": "ex2"}), - "sample_attribute_3": TraitObject({"name": "ex3"}), - "sample_attribute_4": TraitObject({"name": "not_in_extra_attributes"}) - }}) - results = get_categorical_variables(this_trait, sample_list) - self.assertEqual( - ["ex1", "ex2", "ex3", "not_in_extra_attributes"], results) - - def test_get_trait_units(self): - """test for getting trait units""" - trait = TraitObject( - {"description_fmt": "[this is a description] another test [N/A]"}) - trait_no_unit_type = TraitObject({"description_fmt": ""}) - results = get_trait_units(trait) - results_no_unit = get_trait_units(trait_no_unit_type) - self.assertEqual(results, "this is a descriptionN/A") - self.assertEqual(results_no_unit, "value") - - @mock.patch("wqflask.show_trait.show_trait.database_connection") - def test_get_nearest_marker(self, mock_db): - """test for getting nearest marker with non-empty db""" - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - with conn.cursor() as cursor: - cursor.fetchall.return_value = [ - ["Geno1", "Geno2"], ["Geno3"]] - - trait = TraitObject({ - "locus_chr": "test_chr", - "locus_mb": "test_mb" - }) - group_name = TraitObject({"name": "group_name"}) - this_db = TraitObject({"group": group_name}) - results_with_item_db = get_nearest_marker(trait, this_db) - cursor.execute.assert_called_with( - "SELECT Geno.Name FROM Geno, GenoXRef, " - "GenoFreeze WHERE Geno.Chr = %s " - "AND GenoXRef.GenoId = Geno.Id AND " - "GenoFreeze.Id = GenoXRef.GenoFreezeId " - "AND GenoFreeze.Name = %s " - "ORDER BY ABS( Geno.Mb - %s) LIMIT 1", - ('test_chr', 'group_nameGeno', 'test_mb')) - - self.assertEqual(results_with_item_db, "Geno1") - - @mock.patch("wqflask.show_trait.show_trait.database_connection") - def test_get_nearest_marker_empty_db(self, mock_db): - """test for getting nearest marker with empty db""" - conn = mock.MagicMock() - mock_db.return_value.__enter__.return_value = conn - with conn.cursor() as cursor: - cursor.fetchall.return_value = [] - trait = TraitObject({ - "locus_chr": "test_chr", - "locus_mb": "test_mb" - }) - group_name = TraitObject({"name": "group_name"}) - this_db = TraitObject({"group": group_name}) - results_empty_db = get_nearest_marker(trait, this_db) - cursor.execute.assert_called_once() - self.assertEqual(results_empty_db, "") - - @mock.patch("wqflask.show_trait.show_trait.get_scales_from_genofile") - def test_get_genotype_scales_with_genofile_is_list(self, mock_get_scales): - """test for getting genotype scales with genofile as list """ - # where genofile is instance of list - genofiles_list = [{"filename": "file1", "location": "~/data/files/f1"}, - {"filename": "file2", "location": "~/data/files/f2"}, - {"filename": "file3", "location": "~/data/files/f3"}] - - mock_get_scales.side_effect = [[["morgan", "cM"]], - [["morgan", "cM"]], - [["physic", "Mb"]]] - - results = get_genotype_scales(genofiles_list) - expected_results = { - "~/data/files/f1": [["morgan", "cM"]], - "~/data/files/f2": [["morgan", "cM"]], - "~/data/files/f3": [["physic", "Mb"]] - } - - multiple_calls = [mock.call('~/data/files/f1'), mock.call('~/data/files/f2'), - mock.call('~/data/files/f3')] - mock_get_scales.assert_has_calls(multiple_calls) - self.assertEqual(results, expected_results) - - @mock.patch("wqflask.show_trait.show_trait.get_scales_from_genofile") - def test_genotype_scales_with_genofile_other(self, mock_get_scales): - """test for getting genotype scales with genofile as a string""" - file_location = "~/another_file_location" - mock_get_scales.return_value = [["physic", "Mb"]] - expected_results = {f"{file_location}": [["physic", "Mb"]]} - self.assertEqual(get_genotype_scales(file_location), expected_results) - mock_get_scales.assert_called_once_with(file_location) - - @mock.patch("wqflask.show_trait.show_trait.locate_ignore_error") - def test_get_scales_from_genofile_found(self, mock_ignore_location): - """"add test for get scales from genofile where file is found""" - mock_ignore_location.return_value = True - geno_file = """ - #sample line with no @scales:other\n - #sample line @scales and :separated by semicolon\n - This attempts to check whether\n - """ - - geno_file_string = "@line start with @ and has @scale:morgan" - - file_location = "~/data/file.geno" - - mock_open_geno_file = mock.mock_open(read_data=geno_file) - with mock.patch("builtins.open", mock_open_geno_file): - results = get_scales_from_genofile(file_location) - self.assertEqual(results, [["morgan", "cM"]]) - - mock_open_string = mock.mock_open(read_data=geno_file_string) - - with mock.patch("builtins.open", mock_open_string): - result2 = get_scales_from_genofile(file_location) - self.assertEqual([['morgan', 'cM']], result2) - - @mock.patch("wqflask.show_trait.show_trait.locate_ignore_error") - def test_get_scales_from_genofile_not_found(self, mock_location_ignore): - mock_location_ignore.return_value = False - - expected_results = [["physic", "Mb"]] - results = get_scales_from_genofile("~/data/file") - mock_location_ignore.assert_called_once_with("~/data/file", "genotype") - self.assertEqual(results, expected_results) |