aboutsummaryrefslogtreecommitdiff
path: root/wqflask/tests
diff options
context:
space:
mode:
Diffstat (limited to 'wqflask/tests')
-rw-r--r--wqflask/tests/__init__.py0
-rw-r--r--wqflask/tests/integration/__init__.py0
-rw-r--r--wqflask/tests/integration/test_markdown_routes.py21
-rw-r--r--wqflask/tests/unit/__init__.py0
-rw-r--r--wqflask/tests/unit/base/__init__.py0
-rw-r--r--wqflask/tests/unit/base/data.py110
-rw-r--r--wqflask/tests/unit/base/test_data_set.py181
-rw-r--r--wqflask/tests/unit/base/test_general_object.py40
-rw-r--r--wqflask/tests/unit/base/test_trait.py241
-rw-r--r--wqflask/tests/unit/base/test_webqtl_case_data.py39
-rw-r--r--wqflask/tests/unit/utility/__init__.py0
-rw-r--r--wqflask/tests/unit/utility/test_authentication_tools.py189
-rw-r--r--wqflask/tests/unit/utility/test_chunks.py19
-rw-r--r--wqflask/tests/unit/utility/test_corestats.py55
-rw-r--r--wqflask/tests/unit/utility/test_corr_result_helpers.py32
-rw-r--r--wqflask/tests/unit/utility/test_formatting.py33
-rw-r--r--wqflask/tests/unit/utility/test_hmac.py51
-rw-r--r--wqflask/tests/unit/utility/test_type_checking.py54
-rw-r--r--wqflask/tests/unit/wqflask/__init__.py0
-rw-r--r--wqflask/tests/unit/wqflask/api/__init__.py0
-rw-r--r--wqflask/tests/unit/wqflask/api/test_correlation.py153
-rw-r--r--wqflask/tests/unit/wqflask/api/test_gen_menu.py414
-rw-r--r--wqflask/tests/unit/wqflask/api/test_mapping.py108
-rw-r--r--wqflask/tests/unit/wqflask/correlation/__init__.py0
-rw-r--r--wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py20
-rw-r--r--wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py98
-rw-r--r--wqflask/tests/unit/wqflask/marker_regression/__init__.py0
-rw-r--r--wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py156
-rw-r--r--wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py181
-rw-r--r--wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py85
-rw-r--r--wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py21
-rw-r--r--wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py48
-rw-r--r--wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py289
-rw-r--r--wqflask/tests/unit/wqflask/show_trait/__init__.py0
-rw-r--r--wqflask/tests/unit/wqflask/show_trait/test_export_trait_data.py212
-rw-r--r--wqflask/tests/unit/wqflask/snp_browser/__init__.py0
-rw-r--r--wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py105
-rw-r--r--wqflask/tests/unit/wqflask/test_collect.py73
-rw-r--r--wqflask/tests/unit/wqflask/test_markdown_routes.py54
-rw-r--r--wqflask/tests/unit/wqflask/test_pbkdf2.py61
-rw-r--r--wqflask/tests/unit/wqflask/test_server_side.py31
-rw-r--r--wqflask/tests/unit/wqflask/test_user_login.py21
-rw-r--r--wqflask/tests/unit/wqflask/test_user_session.py15
-rw-r--r--wqflask/tests/wqflask/show_trait/testSampleList.py16
-rw-r--r--wqflask/tests/wqflask/show_trait/test_show_trait.py278
45 files changed, 3504 insertions, 0 deletions
diff --git a/wqflask/tests/__init__.py b/wqflask/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/__init__.py
diff --git a/wqflask/tests/integration/__init__.py b/wqflask/tests/integration/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/integration/__init__.py
diff --git a/wqflask/tests/integration/test_markdown_routes.py b/wqflask/tests/integration/test_markdown_routes.py
new file mode 100644
index 00000000..5e3e5045
--- /dev/null
+++ b/wqflask/tests/integration/test_markdown_routes.py
@@ -0,0 +1,21 @@
+"Integration tests for markdown routes"
+import unittest
+
+from bs4 import BeautifulSoup
+
+from wqflask import app
+
+
+class TestGenMenu(unittest.TestCase):
+ """Tests for glossary"""
+
+ def setUp(self):
+ self.app = app.test_client()
+
+ def tearDown(self):
+ pass
+
+ def test_glossary_page(self):
+ """Test that the glossary page is rendered properly"""
+ response = self.app.get('/glossary', follow_redirects=True)
+ pass
diff --git a/wqflask/tests/unit/__init__.py b/wqflask/tests/unit/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/unit/__init__.py
diff --git a/wqflask/tests/unit/base/__init__.py b/wqflask/tests/unit/base/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/unit/base/__init__.py
diff --git a/wqflask/tests/unit/base/data.py b/wqflask/tests/unit/base/data.py
new file mode 100644
index 00000000..06a5a989
--- /dev/null
+++ b/wqflask/tests/unit/base/data.py
@@ -0,0 +1,110 @@
+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"
+ ]
+ ]
+ }
+ }
+}
+"""
diff --git a/wqflask/tests/unit/base/test_data_set.py b/wqflask/tests/unit/base/test_data_set.py
new file mode 100644
index 00000000..96563a16
--- /dev/null
+++ b/wqflask/tests/unit/base/test_data_set.py
@@ -0,0 +1,181 @@
+"""Tests for wqflask/base/data_set.py"""
+
+import unittest
+from unittest import mock
+
+from wqflask import app
+from .data import gen_menu_json
+from base.data_set import DatasetType
+
+
+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()
+
+ @mock.patch('base.data_set.g')
+ def test_data_set_type(self, db_mock):
+ """Test that DatasetType returns correctly if the Redis Instance is not empty
+ and the name variable exists in the dictionary
+
+ """
+ with app.app_context():
+ db_mock.get = mock.Mock()
+ redis_mock = mock.Mock()
+ redis_mock.get.return_value = self.test_dataset
+ self.assertEqual(DatasetType(redis_mock)
+ ("All Phenotypes"), "Publish")
+ redis_mock.get.assert_called_once_with("dataset_structure")
+
+ @mock.patch('base.data_set.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()
+ redis_mock.get.return_value = None
+ data_set = DatasetType(redis_mock)
+ self.assertEqual(data_set("BXDGeno"), "Geno")
+ self.assertEqual(data_set("BXDPublish"), "Publish")
+ self.assertEqual(data_set("HLC_0311"), "ProbeSet")
+
+ redis_mock.set.assert_called_once_with(
+ "dataset_structure",
+ ('{"HLC_0311": "ProbeSet", '
+ '"HLCPublish": "Publish", '
+ '"BXDGeno": "Geno", '
+ '"HC_M2_0606_P": "ProbeSet", '
+ '"BXDPublish": "Publish"}'))
+
+ @mock.patch('base.data_set.g')
+ def test_set_dataset_key_mrna(self, db_mock):
+ with app.app_context():
+ db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
+ redis_mock = mock.Mock()
+ redis_mock.get.return_value = self.test_dataset
+ data_set = DatasetType(redis_mock)
+ data_set.set_dataset_key("mrna_expr", "Test")
+ self.assertEqual(data_set("Test"), "ProbeSet")
+ redis_mock.set.assert_called_once_with(
+ "dataset_structure",
+ ('{"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", '
+ '"Test": "ProbeSet"}'))
+
+ db_mock.db.execute.assert_called_with(
+ ("SELECT ProbeSetFreeze.Id FROM ProbeSetFreeze " +
+ "WHERE ProbeSetFreeze.Name = \"Test\" ")
+ )
+
+ @mock.patch('base.data_set.g')
+ def test_set_dataset_key_pheno(self, db_mock):
+ with app.app_context():
+ db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
+ redis_mock = mock.Mock()
+ redis_mock.get.return_value = self.test_dataset
+ data_set = DatasetType(redis_mock)
+ data_set.set_dataset_key("pheno", "Test")
+ self.assertEqual(data_set("Test"), "Publish")
+ redis_mock.set.assert_called_once_with(
+ "dataset_structure",
+ ('{"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", '
+ '"Test": "Publish"}'))
+ db_mock.db.execute.assert_called_with(
+ ("SELECT InfoFiles.GN_AccesionId "
+ "FROM InfoFiles, PublishFreeze, InbredSet "
+ "WHERE InbredSet.Name = 'Test' AND "
+ "PublishFreeze.InbredSetId = InbredSet.Id AND "
+ "InfoFiles.InfoPageName = PublishFreeze.Name")
+ )
+
+ @mock.patch('base.data_set.g')
+ def test_set_dataset_other_pheno(self, db_mock):
+ with app.app_context():
+ db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
+ redis_mock = mock.Mock()
+ redis_mock.get.return_value = self.test_dataset
+ data_set = DatasetType(redis_mock)
+ data_set.set_dataset_key("other_pheno", "Test")
+ self.assertEqual(data_set("Test"), "Publish")
+
+ redis_mock.set.assert_called_once_with(
+ "dataset_structure",
+ ('{"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", '
+ '"Test": "Publish"}'))
+
+ db_mock.db.execute.assert_called_with(
+ ("SELECT PublishFreeze.Name " +
+ "FROM PublishFreeze, InbredSet " +
+ "WHERE InbredSet.Name = 'Test' AND "
+ "PublishFreeze.InbredSetId = InbredSet.Id")
+ )
+
+ @mock.patch('base.data_set.g')
+ def test_set_dataset_geno(self, db_mock):
+ with app.app_context():
+ db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
+ redis_mock = mock.Mock()
+ redis_mock.get.return_value = self.test_dataset
+ data_set = DatasetType(redis_mock)
+ data_set.set_dataset_key("geno", "Test")
+ self.assertEqual(data_set("Test"), "Geno")
+ redis_mock.set.assert_called_once_with(
+ "dataset_structure",
+ ('{"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", '
+ '"Test": "Geno"}'))
+
+ db_mock.db.execute.assert_called_with(
+ ("SELECT GenoFreeze.Id FROM "
+ "GenoFreeze WHERE GenoFreeze.Name = \"Test\" "))
diff --git a/wqflask/tests/unit/base/test_general_object.py b/wqflask/tests/unit/base/test_general_object.py
new file mode 100644
index 00000000..00fd3c72
--- /dev/null
+++ b/wqflask/tests/unit/base/test_general_object.py
@@ -0,0 +1,40 @@
+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_trait.py b/wqflask/tests/unit/base/test_trait.py
new file mode 100644
index 00000000..826ccefd
--- /dev/null
+++ b/wqflask/tests/unit/base/test_trait.py
@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+"""Tests wqflask/base/trait.py"""
+import unittest
+from unittest import mock
+
+from wqflask import app
+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'"""
+
+ def setUp(self):
+ self.app_context = app.app_context()
+ self.app_context.push()
+
+ def tearDown(self):
+ self.app_context.pop()
+
+ def test_retrieve_trait_info_with_empty_dataset(self):
+ """Test that an exception is raised when dataset is empty"""
+ with self.assertRaises(AssertionError):
+ retrieve_trait_info(trait=mock.MagicMock(),
+ dataset={})
+
+ @mock.patch('base.trait.requests.get')
+ @mock.patch('base.trait.g', mock.Mock())
+ def test_retrieve_trait_info_with_empty_trait_info(self,
+ requests_mock):
+ """Empty trait info"""
+ 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())
+ def test_retrieve_trait_info_with_non_empty_trait_info(self,
+ requests_mock):
+ """Test that attributes are set"""
+ mock_dataset = mock.MagicMock()
+ 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())
+ def test_retrieve_trait_info_utf8_parsing(self,
+ requests_mock):
+ """Test that utf-8 strings are parsed correctly"""
+ utf_8_string = "test_string"
+ 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 かいと")
+
+ @mock.patch('base.trait.requests.get')
+ @mock.patch('base.trait.g')
+ @mock.patch('base.trait.get_resource_id')
+ def test_retrieve_trait_info_with_non_empty_lrs(self,
+ resource_id_mock,
+ g_mock,
+ requests_mock):
+ """Test retrieve trait info when lrs has a value"""
+ 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.37, 3, 4, 5], # trait_qtl = g.db.execute(query).fetchone()
+ [2.7333, 2.1204] # 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,
+ "2.4")
+
+ @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")
+
+ @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
new file mode 100644
index 00000000..8e8ba482
--- /dev/null
+++ b/wqflask/tests/unit/base/test_webqtl_case_data.py
@@ -0,0 +1,39 @@
+"""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
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/unit/utility/__init__.py
diff --git a/wqflask/tests/unit/utility/test_authentication_tools.py b/wqflask/tests/unit/utility/test_authentication_tools.py
new file mode 100644
index 00000000..42dcae88
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_authentication_tools.py
@@ -0,0 +1,189 @@
+"""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"
+
+
+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), 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),
+ ['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),
+ "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"),
+ "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),
+ "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
new file mode 100644
index 00000000..8d90a1ec
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_chunks.py
@@ -0,0 +1,19 @@
+"""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
new file mode 100644
index 00000000..cf91a248
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_corestats.py
@@ -0,0 +1,55 @@
+"""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
new file mode 100644
index 00000000..e196fbdf
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_corr_result_helpers.py
@@ -0,0 +1,32 @@
+""" 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
new file mode 100644
index 00000000..9d3033d1
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_formatting.py
@@ -0,0 +1,33 @@
+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
new file mode 100644
index 00000000..13d6261d
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_hmac.py
@@ -0,0 +1,51 @@
+"""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
new file mode 100644
index 00000000..48d110c7
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_type_checking.py
@@ -0,0 +1,54 @@
+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
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/__init__.py
diff --git a/wqflask/tests/unit/wqflask/api/__init__.py b/wqflask/tests/unit/wqflask/api/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/api/__init__.py
diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
new file mode 100644
index 00000000..d0264b87
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -0,0 +1,153 @@
+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.g")
+ def test_convert_to_mouse_gene_id(self, mock_db):
+
+ results = convert_to_mouse_gene_id(species="Other", gene_id="")
+ self.assertEqual(results, None)
+
+ rat_species_results = convert_to_mouse_gene_id(
+ species="rat", gene_id="GH1")
+
+ mock_db.db.execute.return_value.fetchone.side_effect = [
+ AttributeSetter({"mouse": "MG-1"}), AttributeSetter({"mouse": "MG-2"})]
+
+ 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.g")
+ @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"
+
+ }
+ mock_db.db.execute.return_value.fetchone.side_effect = [AttributeSetter(
+ {"value": "V1"}), AttributeSetter({"value": "V2"}), AttributeSetter({"value": "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
new file mode 100644
index 00000000..57eb1650
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
@@ -0,0 +1,414 @@
+"""Test cases for wqflask.api.gen_menu"""
+import unittest
+from unittest import mock
+
+from wqflask import app
+from wqflask.api.gen_menu import gen_dropdown_json
+from wqflask.api.gen_menu import get_species
+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.app_context = app.app_context()
+ self.app_context.push()
+ 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 tearDown(self):
+ self.app_context.pop()
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_get_species(self, db_mock):
+ """Test that assertion is raised when dataset and dataset_name
+ are defined"""
+ db_mock.db.execute.return_value.fetchall.return_value = (
+ ('human', 'Human'),
+ ('mouse', 'Mouse'))
+ self.assertEqual(get_species(),
+ [['human', 'Human'], ['mouse', 'Mouse']])
+ db_mock.db.execute.assert_called_once_with(
+ "SELECT Name, MenuName FROM Species ORDER BY OrderId"
+ )
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_get_groups(self, db_mock):
+ """Test that species groups are grouped correctly"""
+ db_mock.db.execute.return_value.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"]]),
+ self.test_group)
+
+ for name in ["mouse", "human"]:
+ db_mock.db.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)
+ )
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_phenotypes_exist_called_with_correct_query(self, db_mock):
+ """Test that phenotypes_exist is called with the correct query"""
+ db_mock.db.execute.return_value.fetchone.return_value = None
+ phenotypes_exist("test")
+ db_mock.db.execute.assert_called_with(
+ "SELECT Name FROM PublishFreeze "
+ "WHERE PublishFreeze.Name = 'testPublish'"
+ )
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_phenotypes_exist_with_falsy_values(self, db_mock):
+ """Test that phenotype check returns correctly when given
+ a None value"""
+ for x in [None, False, (), [], ""]:
+ db_mock.db.execute.return_value.fetchone.return_value = x
+ self.assertFalse(phenotypes_exist("test"))
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_phenotypes_exist_with_truthy_value(self, db_mock):
+ """Test that phenotype check returns correctly when given Truthy """
+ for x in ["x", ("result"), ["result"], [1]]:
+ db_mock.db.execute.return_value.fetchone.return_value = (x)
+ self.assertTrue(phenotypes_exist("test"))
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_genotypes_exist_called_with_correct_query(self, db_mock):
+ """Test that genotypes_exist is called with the correct query"""
+ db_mock.db.execute.return_value.fetchone.return_value = None
+ genotypes_exist("test")
+ db_mock.db.execute.assert_called_with(
+ "SELECT Name FROM GenoFreeze WHERE GenoFreeze.Name = 'testGeno'"
+ )
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_genotypes_exist_with_falsy_values(self, db_mock):
+ """Test that genotype check returns correctly when given
+ a None value"""
+ for x in [None, False, (), [], ""]:
+ db_mock.db.execute.return_value.fetchone.return_value = x
+ self.assertFalse(genotypes_exist("test"))
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_genotypes_exist_with_truthy_value(self, db_mock):
+ """Test that genotype check returns correctly when given Truthy """
+ for x in ["x", ("result"), ["result"], [1]]:
+ db_mock.db.execute.return_value.fetchone.return_value = (x)
+ self.assertTrue(phenotypes_exist("test"))
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_build_datasets_with_type_phenotypes(self, db_mock):
+ """Test that correct dataset is returned for a phenotype type"""
+ db_mock.db.execute.return_value.fetchall.return_value = (
+ (602, "BXDPublish", "BXD Published Phenotypes"),
+ )
+ self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
+ [['602', "BXDPublish", "BXD Published Phenotypes"]])
+ db_mock.db.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"),
+ [['602', "BXDPublish", "Mouse Phenome Database"]])
+
+ db_mock.db.execute.return_value.fetchall.return_value = ()
+ db_mock.db.execute.return_value.fetchone.return_value = (
+ "BXDPublish", "Mouse Phenome Database"
+ )
+ self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
+ [["None", "BXDPublish", "Mouse Phenome Database"]])
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_build_datasets_with_type_phenotypes_and_no_results(self, db_mock):
+ """Test that correct dataset is returned for a phenotype type with no
+ results
+
+ """
+ db_mock.db.execute.return_value.fetchall.return_value = None
+ db_mock.db.execute.return_value.fetchone.return_value = (121,
+ "text value")
+ self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
+ [["None", "121", "text value"]])
+ db_mock.db.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"
+ )
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_build_datasets_with_type_genotypes(self, db_mock):
+ """Test that correct dataset is returned for a phenotype type"""
+ db_mock.db.execute.return_value.fetchone.return_value = (
+ 635, "HLCPublish", "HLC Published Genotypes"
+ )
+
+ self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
+ [["635", "HLCGeno", "HLC Genotypes"]])
+ db_mock.db.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"
+ )
+ db_mock.db.execute.return_value.fetchone.return_value = ()
+ self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
+ [["None", "HLCGeno", "HLC Genotypes"]])
+
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_build_datasets_with_type_mrna(self, db_mock):
+ """Test that correct dataset is returned for a mRNA
+ expression/ Probeset"""
+ db_mock.db.execute.return_value.fetchall.return_value = (
+ (112, "HC_M2_0606_P",
+ "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
+ self.assertEqual(build_datasets("Mouse", "HLC", "mRNA"), [[
+ "112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"
+ ]])
+ db_mock.db.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')
+ @mock.patch('wqflask.api.gen_menu.g')
+ def test_build_types(self, db_mock, datasets_mock):
+ """Test that correct tissue metadata is returned"""
+ datasets_mock.return_value = [
+ ["112", 'HC_M2_0606_P',
+ "Hippocampus Consortium M430v2 (Jun06) PDNN"]
+ ]
+ db_mock.db.execute.return_value.fetchall.return_value = (
+ ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
+ )
+ self.assertEqual(build_types('mouse', 'random group'),
+ [['M', 'M', 'Molecular Traits'],
+ ['H', 'H', 'Molecular Traits'],
+ ['R', 'R', 'Molecular Traits']])
+ db_mock.db.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), 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), {
+ '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),
+ 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),
+ 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),
+ 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_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(), expected_result)
diff --git a/wqflask/tests/unit/wqflask/api/test_mapping.py b/wqflask/tests/unit/wqflask/api/test_mapping.py
new file mode 100644
index 00000000..b094294a
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/api/test_mapping.py
@@ -0,0 +1,108 @@
+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
+ }
+
+ 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"
+
+ }
+
+ 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"
+ }
+
+ self.assertEqual(results_2, expected_results)
+
+ @mock.patch("wqflask.api.mapping.rqtl_mapping.run_rqtl_geno")
+ @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/correlation/__init__.py b/wqflask/tests/unit/wqflask/correlation/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/correlation/__init__.py
diff --git a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
new file mode 100644
index 00000000..44d2e0fc
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
@@ -0,0 +1,20 @@
+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
+
+
+class TestCorrelationFunctions(unittest.TestCase):
+
+ @mock.patch("wqflask.correlation.correlation_functions.MrnaAssayTissueData")
+ def test_get_trait_symbol_and_tissue_values(self, mock_class):
+ """test for getting trait symbol and tissue_values"""
+ mock_class_instance = mock_class.return_value
+ mock_class_instance.gene_symbols = ["k1", "k2", "k3"]
+ mock_class_instance.get_symbol_values_pairs.return_value = {
+ "k1": ["v1", "v2", "v3"], "k2": ["v2", "v3"], "k3": ["k3"]}
+ results = get_trait_symbol_and_tissue_values(
+ symbol_list=["k1", "k2", "k3"])
+ mock_class.assert_called_with(gene_symbols=['k1', 'k2', 'k3'])
+ self.assertEqual({"k1": ["v1", "v2", "v3"], "k2": [
+ "v2", "v3"], "k3": ["k3"]}, results)
diff --git a/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
new file mode 100644
index 00000000..33601990
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
@@ -0,0 +1,98 @@
+import unittest
+from unittest import mock
+from wqflask.correlation.show_corr_results import get_header_fields
+from wqflask.correlation.show_corr_results import generate_corr_json
+
+
+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])
+
+ @mock.patch("wqflask.correlation.show_corr_results.hmac.data_hmac")
+ def test_generate_corr_json(self, mock_data_hmac):
+ mock_data_hmac.return_value = "hajsdiau"
+
+ dataset = AttributeSetter({"name": "the_name"})
+ this_trait = AttributeSetter(
+ {"name": "trait_test", "dataset": dataset})
+ target_dataset = AttributeSetter({"type": "Publish"})
+ corr_trait_1 = AttributeSetter({
+ "name": "trait_1",
+ "dataset": AttributeSetter({"name": "dataset_1"}),
+ "view": True,
+ "abbreviation": "T1",
+ "description_display": "Trait I description",
+ "authors": "JM J,JYEW",
+ "pubmed_id": "34n4nn31hn43",
+ "pubmed_text": "2016",
+ "pubmed_link": "https://www.load",
+ "lod_score": "",
+ "mean": "",
+ "LRS_location_repr": "BXBS",
+ "additive": "",
+ "sample_r": 10.5,
+ "num_overlap": 2,
+ "sample_p": 5
+
+
+
+
+ })
+ corr_results = [corr_trait_1]
+
+ dataset_type_other = {
+ "location": "cx-3-4",
+ "sample_4": 12.32,
+ "num_overlap": 3,
+ "sample_p": 10.34
+ }
+
+ expected_results = '[{"index": 1, "trait_id": "trait_1", "dataset": "dataset_1", "hmac": "hajsdiau", "abbreviation_display": "T1", "description": "Trait I description", "mean": "N/A", "authors_display": "JM J,JYEW", "additive": "N/A", "pubmed_id": "34n4nn31hn43", "year": "2016", "lod_score": "N/A", "lrs_location": "BXBS", "sample_r": "10.500", "num_overlap": 2, "sample_p": "5.000e+00"}]'
+
+ results1 = generate_corr_json(corr_results=corr_results, this_trait=this_trait,
+ dataset=dataset, target_dataset=target_dataset, for_api=True)
+ self.assertEqual(expected_results, results1)
+
+ def test_generate_corr_json_view_false(self):
+ trait = AttributeSetter({"view": False})
+ corr_results = [trait]
+ this_trait = AttributeSetter({"name": "trait_test"})
+ dataset = AttributeSetter({"name": "the_name"})
+
+ results_where_view_is_false = generate_corr_json(
+ corr_results=corr_results, this_trait=this_trait, dataset={}, target_dataset={}, for_api=False)
+ self.assertEqual(results_where_view_is_false, "[]")
diff --git a/wqflask/tests/unit/wqflask/marker_regression/__init__.py b/wqflask/tests/unit/wqflask/marker_regression/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/__init__.py
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
new file mode 100644
index 00000000..8ae0f09f
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
@@ -0,0 +1,156 @@
+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
new file mode 100644
index 00000000..fe2569b8
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -0,0 +1,181 @@
+# test for wqflask/marker_regression/gemma_mapping.py
+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):
+ 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", "/home/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": 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 = "/home/genotype/bimbam"
+ mock_parse_loco.return_value = []
+ results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[
+ ], vals=[], covariates="", use_loco=True)
+ self.assertEqual(mock_os.system.call_count,2)
+ 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(mock_flat_files.call_count, 4)
+ 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={}, genofile_name="", vals=[
+ "x", "w", "q", "we", "R"], trait_filename="fitr.re")
+ mock_open.assert_called_once_with(
+ '/home/user/data/gn2/fitr.re.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})
+ 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/group_X_covariates.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': 23.3, 'lod_score': 0.07058107428570727},
+ {'name': 'M2', 'chr': 4, 'Mb': 1.2e-05, 'p_value': 0.5, 'additive': 24.0, 'lod_score': 0.3010299956639812},
+ {'name': 'M4', 'chr': 'Y', 'Mb': 1.2e-05, 'p_value': 0.7, 'additive': 11.6, 'lod_score': 0.1549019599857432},
+ {'name': 'M5', 'chr': 'X', 'Mb': 1.2e-05, 'p_value': 0.6, 'additive': 21.1, '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
new file mode 100644
index 00000000..5eec93f1
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
@@ -0,0 +1,85 @@
+# 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
new file mode 100644
index 00000000..b47f877a
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -0,0 +1,21 @@
+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
new file mode 100644
index 00000000..c585f1df
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -0,0 +1,48 @@
+import unittest
+from unittest import mock
+from wqflask import app
+from wqflask.marker_regression.rqtl_mapping import get_trait_data_type
+from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_phenotype
+from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_names
+
+class TestRqtlMapping(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.marker_regression.rqtl_mapping.g")
+ @mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
+ def test_get_trait_data(self,mock_logger,mock_db):
+ """test for getting trait data_type return True"""
+ query_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
+ mock_db.db.execute.return_value.fetchone.return_value=["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
+ results=get_trait_data_type("traid_id")
+ mock_db.db.execute.assert_called_with(query_value)
+ self.assertEqual(results,"fer434f")
+
+ def test_sanitize_rqtl_phenotype(self):
+ """test for sanitizing rqtl phenotype"""
+ vals=['f',"x","r","x","x"]
+ results=sanitize_rqtl_phenotype(vals)
+ expected_phenotype_string='c(f,NA,r,NA,NA)'
+
+ self.assertEqual(results,expected_phenotype_string)
+
+ def test_sanitize_rqtl_names(self):
+ """test for sanitzing rqtl names"""
+ vals=['f',"x","r","x","x"]
+ expected_sanitized_name="c('f',NA,'r',NA,NA)"
+ results=sanitize_rqtl_names(vals)
+ self.assertEqual(expected_sanitized_name,results)
+
+
+
+
+
+
+
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
new file mode 100644
index 00000000..a29d8cfb
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -0,0 +1,289 @@
+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": "dataser_1", "group": self.group, "type": "ProbeSet"})
+
+ self.chromosomes = AttributeSetter({"chromosomes": chromosomes})
+ self.trait = AttributeSetter(
+ {"symbol": "IGFI", "chr": "X1", "mb": 123313})
+
+ 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_scale="physic", score_type="-log(p)",
+ transform="qnorm", covariates="Dataset1:Trait1,Dataset2:Trait2", n_samples="100")
+
+ write_calls = [
+ mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
+ mock.call('Population: Human GP1_\n'), mock.call(
+ 'Data Set: dataser_1\n'),
+ mock.call('N Samples: 100\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,-log(p)'), mock.call('Cm,-log(p)'),
+ mock.call(',Additive'), mock.call(',Dominance'),
+ mock.call('\n'), mock.call('MK1,C1,'),
+ mock.call('12000,'), mock.call('1,'),
+ mock.call('3'), mock.call(',VA'),
+ mock.call(',TT'), mock.call('\n'),
+ mock.call('MK2,C2,'), mock.call('10000,'),
+ mock.call('15,'), mock.call('7'),
+ mock.call('\n'), mock.call('MK1,C3,'),
+ mock.call('1,'), mock.call('45,'),
+ 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, [2, 1])
+
+ def test_get_chr_length(self):
+ """test for getting chromosome length"""
+ 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.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
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/show_trait/__init__.py
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
new file mode 100644
index 00000000..41761944
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/show_trait/test_export_trait_data.py
@@ -0,0 +1,212 @@
+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 related to converting dict to sortedlist"""
+ @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_no_publish(self, mock_dataset, mock_trait):
+ """test for exporting metadata with no publish"""
+ mock_dataset_attributes = AttributesSetter(
+ {"type": "no_publish", "dataset_name": "Temp", "name": "Temp"})
+
+ mock_nested_attributes = AttributesSetter({"name": "name"})
+ mock_dataset_attributes.group = mock_nested_attributes
+ mock_dataset.create_dataset.return_value = mock_dataset_attributes
+ mock_trait.return_value = AttributesSetter({"symbol": "", "description_display": "Description",
+ "title": "research1", "journal": "", "authors": ""})
+
+ results = get_export_metadata("random_id", "Temp")
+ expected = [["Record ID: random_id"],
+ ["Trait URL: http://genenetwork.org/show_trait?trait_id=random_id&dataset=Temp"],
+ ["Dataset: Temp"],
+ ["Group: name"], []]
+
+ mock_dataset.create_dataset.assert_called_with("Temp")
+ mock_trait.assert_called_with(
+ dataset=mock_dataset_attributes, name="random_id", cellid=None, get_qtl_info=False)
+ self.assertEqual(results, expected)
+
+ @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_with_publish(self, data_mock, trait_mock):
+ """test for exporting metadata with dataset.type=Publish"""
+ mock_dataset_attributes = AttributesSetter({"type": "Publish", "dataset_name": "Temp",
+ "name": "Temp", "description_display": "Description goes here"})
+
+ mock_nested_attributes = AttributesSetter({"name": "name"})
+ mock_dataset_attributes.group = mock_nested_attributes
+ data_mock.create_dataset.return_value = mock_dataset_attributes
+ trait_instance = AttributesSetter({"symbol": "", "description_display": "Description",
+ "title": "research1", "journal": "", "authors": ""})
+ trait_mock.return_value = trait_instance
+
+ results = get_export_metadata(
+ "29ae0615-0d77-4814-97c7-c9e91f6bfd7b", "Temp")
+
+ expected = [['Phenotype ID: 29ae0615-0d77-4814-97c7-c9e91f6bfd7b'],
+ ['Phenotype URL: http://genenetwork.org/show_trait?trait_id=29ae0615-0d77-4814-97c7-c9e91f6bfd7b&dataset=Temp'], [
+ 'Group: name'], ['Phenotype: Description'],
+ ['Authors: N/A'], ['Title: research1'],
+ ['Journal: N/A'], ['Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=Temp'], []]
+
+ self.assertEqual(results, expected)
+
+ @mock.patch("wqflask.show_trait.export_trait_data.dict_to_sorted_list")
+ @mock.patch("wqflask.show_trait.export_trait_data.get_export_metadata")
+ def test_export_sample_table(self, exp_metadata, dict_list):
+ """test for exporting sample table"""
+ targs_obj = {
+ "export_data": """{
+ "primary_samples": [
+ {
+ "other": "germanotta",
+ "name": "Sauroniops",
+ "se":{
+ "name":"S2"
+ },
+ "num_cases":{
+ "k1":"value"
+
+ }
+ }
+ ],
+ "other_samples": [
+ {
+ "se": 1,
+ "num_cases": 4,
+ "value": 6,
+ "name": 3
+ }
+ ]
+ }""",
+ "trait_display_name": "Hair_color",
+ "trait_id": "23177fdc-312e-4084-ad0c-f3eae785fff5",
+ "dataset": {
+ }
+ }
+ exp_metadata.return_value = [
+ ["Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f"], ['Group:gp1'],
+ ["Phenotype:p1"], [
+ "Authors:N/A"],
+ ["Title:research1"],
+ ["Journal:N/A"],
+ ["Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1"], []]
+ expected = ('Hair_color',
+ [['Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f'],
+ ['Group:gp1'],
+ ['Phenotype:p1'],
+ ['Authors:N/A'],
+ ['Title:research1'],
+ ['Journal:N/A'],
+ ['Dataset Link: '
+ 'http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1'],
+ [],
+ ['Name', 'Value', 'SE', 'N'],
+ ['Sauroniops', 'germanotta'],
+ [3, 6, 1, 4]])
+
+ dict_list.side_effect = [['Sauroniops', 'germanotta'], [3, 6, 1, 4]]
+
+ self.assertEqual(export_sample_table(targs_obj), expected)
+ exp_metadata.assert_called_with(
+ "23177fdc-312e-4084-ad0c-f3eae785fff5", {})
+ self.assertEqual(dict_list.call_count, 2)
+
+ 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/snp_browser/__init__.py b/wqflask/tests/unit/wqflask/snp_browser/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/snp_browser/__init__.py
diff --git a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
new file mode 100644
index 00000000..ce3e7b83
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
@@ -0,0 +1,105 @@
+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.g")
+ def test_get_gene_id(self, mock_db):
+ mock_db.db.execute.return_value.fetchone.return_value = "517d729f-aa13-4413-a885-40a3f7ff768a"
+ db_query_value = """
+ SELECT
+ geneId
+ FROM
+ GeneList
+ WHERE
+ SpeciesId = c9c0f59e-1259-4cba-91e6-831ef1a99c83 AND geneSymbol = 'INSR'
+ """
+ results = get_gene_id(
+ species_id="c9c0f59e-1259-4cba-91e6-831ef1a99c83", gene_name="INSR")
+ mock_db.db.execute.assert_called_once_with(db_query_value)
+ self.assertEqual(results, "517d729f-aa13-4413-a885-40a3f7ff768a")
+
+ @mock.patch("wqflask.snp_browser.snp_browser.g")
+ def test_gene_id_name_dict(self, mock_db):
+ no_gene_names = []
+ self.assertEqual("", get_gene_id_name_dict(
+ species_id="fregb343bui43g4", gene_name_list=no_gene_names))
+ gene_name_list = ["GH1", "GH2", "GH3"]
+ mock_db.db.execute.return_value.fetchall.side_effect = [[], [("fsdf43-fseferger-f22", "GH1"), ("1sdf43-fsewferger-f22", "GH2"),
+ ("fwdj43-fstferger-f22", "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 = ret3-32rf32 AND geneSymbol in ('GH1','GH2','GH3')
+ """
+ mock_db.db.execute.assert_called_with(db_query_value)
+ self.assertEqual(results_found, expected_found)
+ self.assertEqual(no_results, {})
+
+ @mock.patch("wqflask.snp_browser.snp_browser.g")
+ def test_check_if_in_gene(self, mock_db):
+ mock_db.db.execute.return_value.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)
+ db_query_value = """SELECT geneId, geneSymbol
+ FROM GeneList
+ WHERE SpeciesId = 517d729f-aa13-4413-a885-40a3f7ff768a AND chromosome = 'CH1' AND
+ (txStart < 12.09 AND txEnd > 12.09); """
+ gene_not_found = check_if_in_gene(
+ species_id="517d729f-aa13-4413-a885-40a3f7ff768a", chr="CH1", mb=12.09)
+ mock_db.db.execute.assert_called_with(db_query_value)
+ self.assertEqual(gene_not_found, "")
+
+ @mock.patch("wqflask.snp_browser.snp_browser.g")
+ def test_get_browser_sample_lists(self, mock_db):
+ mock_db.db.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
new file mode 100644
index 00000000..9a36132d
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_collect.py
@@ -0,0 +1,73 @@
+"""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(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'),
+ set(['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(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'),
+ set(['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_markdown_routes.py b/wqflask/tests/unit/wqflask/test_markdown_routes.py
new file mode 100644
index 00000000..90e0f17c
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_markdown_routes.py
@@ -0,0 +1,54 @@
+"""Test functions in markdown utils"""
+
+import unittest
+from unittest import mock
+
+from dataclasses import dataclass
+from wqflask.markdown_routes 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_routes"""
+
+ @mock.patch('wqflask.markdown_routes.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.assertRegexpMatches(markdown_content,
+ "Content for general/glossary/glossary.md not available.")
+
+ @mock.patch('wqflask.markdown_routes.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/test_pbkdf2.py b/wqflask/tests/unit/wqflask/test_pbkdf2.py
new file mode 100644
index 00000000..7ad6c83e
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_pbkdf2.py
@@ -0,0 +1,61 @@
+"""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_server_side.py b/wqflask/tests/unit/wqflask/test_server_side.py
new file mode 100644
index 00000000..4f91d8ca
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_server_side.py
@@ -0,0 +1,31 @@
+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
new file mode 100644
index 00000000..61cd9ab9
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_user_login.py
@@ -0,0 +1,21 @@
+"""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
new file mode 100644
index 00000000..ebb0334a
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_user_session.py
@@ -0,0 +1,15 @@
+"""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/wqflask/show_trait/testSampleList.py b/wqflask/tests/wqflask/show_trait/testSampleList.py
new file mode 100644
index 00000000..34c51e3e
--- /dev/null
+++ b/wqflask/tests/wqflask/show_trait/testSampleList.py
@@ -0,0 +1,16 @@
+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
new file mode 100644
index 00000000..8c866874
--- /dev/null
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -0,0 +1,278 @@
+"""test for wqflask/show_trait/test_show_trait.py"""
+import unittest
+from unittest import mock
+from wqflask import app
+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 requests
+from wqflask.show_trait.show_trait import get_scales_from_genofile
+
+
+class TraitObject:
+ def __init__(self, obj):
+ for key, value in obj.items():
+ setattr(self, key, value)
+
+
+class TestTraits(unittest.TestCase):
+ def setUp(self):
+ self.app_context = app.app_context()
+ self.app_context.push()
+
+ def tearDown(self):
+ self.app_context.pop()
+
+ def test_check_if_attr_exists_truthy(self):
+ """"test if attributes exists with true return"""
+ trait_obj = TraitObject({"id_type": "id"})
+ trait_obj2 = TraitObject({"sample_name": ['samp1']})
+ results = check_if_attr_exists(trait_obj, "id_type")
+ result2 = check_if_attr_exists(trait_obj2, "sample_name")
+ self.assertIsInstance(trait_obj, TraitObject)
+ self.assertTrue(results)
+ self.assertTrue(result2)
+
+ def test_check_if_attr_exists_empty_attr(self):
+ """test if attributes exists with false return"""
+ trait_obj = TraitObject({"sample": ""})
+ trait_obj2 = TraitObject({"group": None})
+ result = check_if_attr_exists(trait_obj, "sample")
+ result2 = check_if_attr_exists(trait_obj, "group")
+ self.assertFalse(result)
+ self.assertFalse(result2)
+
+ def test_check_if_attr_exists_falsey(self):
+ """check if attribute exists with empty attributes"""
+ trait_obj = TraitObject({})
+ results = check_if_attr_exists(trait_obj, "any")
+ self.assertFalse(results)
+
+ @mock.patch("wqflask.show_trait.show_trait.requests.get")
+ @mock.patch("wqflask.show_trait.show_trait.check_if_attr_exists")
+ def test_get_ncbi_summary_request_success(self, mock_exists, mock_get):
+ """test for getting ncbi summary with
+ successful request"""
+ trait = TraitObject({"geneid": "id"})
+ mock_exists.return_value = True
+ content_json_string = """{
+ "result":{
+ "id":{
+ "summary":"this is a summary of the geneid"
+ }
+ }
+ }
+ """
+ get_return_obj = TraitObject({"content": content_json_string})
+ mock_get.return_value = get_return_obj
+ results = get_ncbi_summary(trait)
+ mock_exists.assert_called_once()
+ mock_get.assert_called_once_with(f"http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=gene&id={trait.geneid}&retmode=json")
+
+ self.assertEqual(results, "this is a summary of the geneid")
+
+ @mock.patch("wqflask.show_trait.show_trait.requests.get")
+ @mock.patch("wqflask.show_trait.show_trait.check_if_attr_exists")
+ def test_get_ncbi_summary_request_fail(self, mock_exists, mock_get_fail):
+ """test for getting ncbi summary with request fail"""
+ trait = TraitObject({"geneid": "id"})
+ mock_exists.return_value = True
+ mock_get_fail.side_effect = Exception("an error occurred")
+ content_json_string = """{
+ "result":{
+ "id":{
+ "summary":"this is a summary of the geneid"
+ }
+ }
+ }
+ """
+ results = get_ncbi_summary(trait)
+ self.assertEqual(results, None)
+
+ 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, "750px")
+ expected_no_numcase = (450, "670px")
+ expected_one_sample = (250, "540px")
+ 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.g")
+ def test_get_nearest_marker(self, mock_db):
+ """test for getting nearest marker with non-empty db"""
+
+ mock_db.db.execute.return_value.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)
+ called_with_value = """SELECT Geno.Name
+ FROM Geno, GenoXRef, GenoFreeze
+ WHERE Geno.Chr = 'test_chr' AND
+ GenoXRef.GenoId = Geno.Id AND
+ GenoFreeze.Id = GenoXRef.GenoFreezeId AND
+ GenoFreeze.Name = 'group_nameGeno'
+ ORDER BY ABS( Geno.Mb - test_mb) LIMIT 1"""
+
+ mock_db.db.execute.assert_called_with(called_with_value)
+
+ self.assertEqual(results_with_item_db, "Geno1")
+
+ @mock.patch("wqflask.show_trait.show_trait.g")
+ def test_get_nearest_marker_empty_db(self, mock_db):
+ """test for getting nearest marker with empty db"""
+ mock_db.db.execute.return_value.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)
+ mock_db.db.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)