From 204a308be0f741726b9a620d88fbc22b22124c81 Mon Sep 17 00:00:00 2001
From: Arun Isaac
Date: Fri, 29 Dec 2023 18:55:37 +0000
Subject: Namespace all modules under gn2.
We move all modules under a gn2 directory. This is important for
"correct" packaging and deployment as a Guix service.
---
gn2/tests/unit/wqflask/__init__.py | 0
gn2/tests/unit/wqflask/api/__init__.py | 0
gn2/tests/unit/wqflask/api/test_correlation.py | 175 +++++++++
gn2/tests/unit/wqflask/api/test_gen_menu.py | 423 +++++++++++++++++++++
gn2/tests/unit/wqflask/api/test_mapping.py | 113 ++++++
gn2/tests/unit/wqflask/api/test_markdown_routes.py | 54 +++
gn2/tests/unit/wqflask/correlation/__init__.py | 0
.../correlation/test_correlation_functions.py | 21 +
.../wqflask/correlation/test_correlation_gn3.py | 14 +
.../wqflask/correlation/test_show_corr_results.py | 42 ++
.../unit/wqflask/marker_regression/__init__.py | 0
.../genotype/bimbam/file_geno.txt | 0
.../genotype/bimbam/file_snps.txt | 0
.../test_display_mapping_results.py | 159 ++++++++
.../marker_regression/test_gemma_mapping.py | 188 +++++++++
.../marker_regression/test_plink_mapping.py | 86 +++++
.../marker_regression/test_qtlreaper_mapping.py | 24 ++
.../wqflask/marker_regression/test_rqtl_mapping.py | 43 +++
.../wqflask/marker_regression/test_run_mapping.py | 288 ++++++++++++++
gn2/tests/unit/wqflask/show_trait/__init__.py | 0
.../wqflask/show_trait/test_export_trait_data.py | 151 ++++++++
.../unit/wqflask/show_trait/test_get_max_digits.py | 15 +
gn2/tests/unit/wqflask/snp_browser/__init__.py | 0
.../unit/wqflask/snp_browser/test_snp_browser.py | 206 ++++++++++
gn2/tests/unit/wqflask/test_collect.py | 75 ++++
gn2/tests/unit/wqflask/test_pbkdf2.py | 61 +++
gn2/tests/unit/wqflask/test_resource_manager.py | 94 +++++
gn2/tests/unit/wqflask/test_server_side.py | 34 ++
gn2/tests/unit/wqflask/test_user_login.py | 21 +
gn2/tests/unit/wqflask/test_user_session.py | 15 +
gn2/tests/unit/wqflask/wgcna/__init__.py | 0
gn2/tests/unit/wqflask/wgcna/test_wgcna.py | 50 +++
32 files changed, 2352 insertions(+)
create mode 100644 gn2/tests/unit/wqflask/__init__.py
create mode 100644 gn2/tests/unit/wqflask/api/__init__.py
create mode 100644 gn2/tests/unit/wqflask/api/test_correlation.py
create mode 100644 gn2/tests/unit/wqflask/api/test_gen_menu.py
create mode 100644 gn2/tests/unit/wqflask/api/test_mapping.py
create mode 100644 gn2/tests/unit/wqflask/api/test_markdown_routes.py
create mode 100644 gn2/tests/unit/wqflask/correlation/__init__.py
create mode 100644 gn2/tests/unit/wqflask/correlation/test_correlation_functions.py
create mode 100644 gn2/tests/unit/wqflask/correlation/test_correlation_gn3.py
create mode 100644 gn2/tests/unit/wqflask/correlation/test_show_corr_results.py
create mode 100644 gn2/tests/unit/wqflask/marker_regression/__init__.py
create mode 100644 gn2/tests/unit/wqflask/marker_regression/genotype/bimbam/file_geno.txt
create mode 100644 gn2/tests/unit/wqflask/marker_regression/genotype/bimbam/file_snps.txt
create mode 100644 gn2/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
create mode 100644 gn2/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
create mode 100644 gn2/tests/unit/wqflask/marker_regression/test_plink_mapping.py
create mode 100644 gn2/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
create mode 100644 gn2/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
create mode 100644 gn2/tests/unit/wqflask/marker_regression/test_run_mapping.py
create mode 100644 gn2/tests/unit/wqflask/show_trait/__init__.py
create mode 100644 gn2/tests/unit/wqflask/show_trait/test_export_trait_data.py
create mode 100644 gn2/tests/unit/wqflask/show_trait/test_get_max_digits.py
create mode 100644 gn2/tests/unit/wqflask/snp_browser/__init__.py
create mode 100644 gn2/tests/unit/wqflask/snp_browser/test_snp_browser.py
create mode 100644 gn2/tests/unit/wqflask/test_collect.py
create mode 100644 gn2/tests/unit/wqflask/test_pbkdf2.py
create mode 100644 gn2/tests/unit/wqflask/test_resource_manager.py
create mode 100644 gn2/tests/unit/wqflask/test_server_side.py
create mode 100644 gn2/tests/unit/wqflask/test_user_login.py
create mode 100644 gn2/tests/unit/wqflask/test_user_session.py
create mode 100644 gn2/tests/unit/wqflask/wgcna/__init__.py
create mode 100644 gn2/tests/unit/wqflask/wgcna/test_wgcna.py
(limited to 'gn2/tests/unit/wqflask')
diff --git a/gn2/tests/unit/wqflask/__init__.py b/gn2/tests/unit/wqflask/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/gn2/tests/unit/wqflask/api/__init__.py b/gn2/tests/unit/wqflask/api/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/gn2/tests/unit/wqflask/api/test_correlation.py b/gn2/tests/unit/wqflask/api/test_correlation.py
new file mode 100644
index 00000000..8835375d
--- /dev/null
+++ b/gn2/tests/unit/wqflask/api/test_correlation.py
@@ -0,0 +1,175 @@
+import unittest
+from unittest import mock
+from gn2.wqflask import app
+from collections import OrderedDict
+from gn2.wqflask.api.correlation import init_corr_params
+from gn2.wqflask.api.correlation import convert_to_mouse_gene_id
+from gn2.wqflask.api.correlation import do_literature_correlation_for_all_traits
+from gn2.wqflask.api.correlation import get_sample_r_and_p_values
+from gn2.wqflask.api.correlation import calculate_results
+
+
+class AttributeSetter:
+ def __init__(self, obj):
+ for k, v in obj.items():
+ setattr(self, k, v)
+
+
+class MockDataset(AttributeSetter):
+ def get_trait_data(self):
+ return None
+
+ def retrieve_genes(self, id=None):
+ return {"TT-1": "GH-1", "TT-2": "GH-2", "TT-3": "GH-3"}
+
+
+class TestCorrelations(unittest.TestCase):
+ def setUp(self):
+ self.app_context = app.app_context()
+ self.app_context.push()
+
+ def tearDown(self):
+ self.app_context.pop()
+
+ def test_init_corr_params(self):
+ start_vars = {"return_count": "3", "type": "T1", "method": "spearman"}
+
+ corr_params_results = init_corr_params(start_vars=start_vars)
+ expected_results = {"return_count": 3, "type": "T1", "method": "spearman"}
+
+ self.assertEqual(corr_params_results, expected_results)
+
+ @mock.patch("wqflask.api.correlation.database_connection")
+ def test_convert_to_mouse_gene_id(self, mock_db):
+ conn = mock.MagicMock()
+ mock_db.return_value.__enter__.return_value = conn
+ with conn.cursor() as cursor:
+ cursor.fetchone.side_effect = [("MG-1",), ("MG-2",)]
+
+ self.assertEqual(
+ convert_to_mouse_gene_id(species="Other", gene_id=""), None
+ )
+ self.assertEqual(
+ convert_to_mouse_gene_id(species="mouse", gene_id="MG-4"), "MG-4"
+ )
+ self.assertEqual(
+ convert_to_mouse_gene_id(species="rat", gene_id="R1"), "MG-1"
+ )
+ self.assertEqual(
+ convert_to_mouse_gene_id(species="human", gene_id="H1"), "MG-2"
+ )
+
+ @mock.patch("wqflask.api.correlation.database_connection")
+ @mock.patch("wqflask.api.correlation.convert_to_mouse_gene_id")
+ def test_do_literature_correlation_for_all_traits(
+ self, mock_convert_to_mouse_geneid, mock_db
+ ):
+ mock_convert_to_mouse_geneid.side_effect = ["MG-1", "MG-2;", "MG-3", "MG-4"]
+
+ trait_geneid_dict = {"TT-1": "GH-1", "TT-2": "GH-2", "TT-3": "GH-3"}
+ conn = mock.MagicMock()
+ mock_db.return_value.__enter__.return_value = conn
+ with conn.cursor() as cursor:
+ cursor.fetchone.side_effect = [("V1",), ("V2",), ("V3",)]
+ this_trait = AttributeSetter({"geneid": "GH-1"})
+ target_dataset = AttributeSetter(
+ {"group": AttributeSetter({"species": "rat"})}
+ )
+ results = do_literature_correlation_for_all_traits(
+ this_trait=this_trait,
+ target_dataset=target_dataset,
+ trait_geneid_dict=trait_geneid_dict,
+ corr_params={},
+ )
+ expected_results = {
+ "TT-1": ["GH-1", 0],
+ "TT-2": ["GH-2", "V1"],
+ "TT-3": ["GH-3", "V2"],
+ }
+ self.assertEqual(results, expected_results)
+
+ @mock.patch("wqflask.api.correlation.corr_result_helpers.normalize_values")
+ def test_get_sample_r_and_p_values(self, mock_normalize):
+
+ group = AttributeSetter(
+ {"samplelist": ["S1", "S2", "S3", "S4", "S5", "S6", "S7"]}
+ )
+ target_dataset = AttributeSetter({"group": group})
+
+ target_vals = [3.4, 6.2, 4.1, 3.4, 1.2, 5.6]
+ trait_data = {
+ "S1": AttributeSetter({"value": 2.3}),
+ "S2": AttributeSetter({"value": 1.1}),
+ "S3": AttributeSetter({"value": 6.3}),
+ "S4": AttributeSetter({"value": 3.6}),
+ "S5": AttributeSetter({"value": 4.1}),
+ "S6": AttributeSetter({"value": 5.0}),
+ }
+ this_trait = AttributeSetter({"data": trait_data})
+ mock_normalize.return_value = (
+ [2.3, 1.1, 6.3, 3.6, 4.1, 5.0],
+ [3.4, 6.2, 4.1, 3.4, 1.2, 5.6],
+ 6,
+ )
+ mock_normalize.side_effect = [
+ ([2.3, 1.1, 6.3, 3.6, 4.1, 5.0], [3.4, 6.2, 4.1, 3.4, 1.2, 5.6], 6),
+ ([2.3, 1.1, 6.3, 3.6, 4.1, 5.0], [3.4, 6.2, 4.1, 3.4, 1.2, 5.6], 6),
+ ([2.3, 1.1, 1.4], [3.4, 6.2, 4.1], 3),
+ ]
+
+ results_pearsonr = get_sample_r_and_p_values(
+ this_trait=this_trait,
+ this_dataset={},
+ target_vals=target_vals,
+ target_dataset=target_dataset,
+ type="pearson",
+ )
+ results_spearmanr = get_sample_r_and_p_values(
+ this_trait=this_trait,
+ this_dataset={},
+ target_vals=target_vals,
+ target_dataset=target_dataset,
+ type="spearman",
+ )
+ results_num_overlap = get_sample_r_and_p_values(
+ this_trait=this_trait,
+ this_dataset={},
+ target_vals=target_vals,
+ target_dataset=target_dataset,
+ type="pearson",
+ )
+ expected_pearsonr = [-0.21618688834430866, 0.680771605997119, 6]
+ expected_spearmanr = [-0.11595420713048969, 0.826848213385815, 6]
+ for i, val in enumerate(expected_pearsonr):
+ self.assertAlmostEqual(val, results_pearsonr[i], 4)
+ for i, val in enumerate(expected_spearmanr):
+ self.assertAlmostEqual(val, results_spearmanr[i], 4)
+ self.assertEqual(results_num_overlap, None)
+
+ @mock.patch("wqflask.api.correlation.do_literature_correlation_for_all_traits")
+ def test_calculate_results(self, literature_correlation):
+
+ literature_correlation.return_value = {
+ "TT-1": ["GH-1", 0],
+ "TT-2": ["GH-2", 3],
+ "TT-3": ["GH-3", 1],
+ }
+
+ this_dataset = MockDataset({"group": AttributeSetter({"species": "rat"})})
+ target_dataset = MockDataset({"group": AttributeSetter({"species": "rat"})})
+ this_trait = AttributeSetter({"geneid": "GH-1"})
+ corr_params = {"type": "literature"}
+ sorted_results = calculate_results(
+ this_trait=this_trait,
+ this_dataset=this_dataset,
+ target_dataset=target_dataset,
+ corr_params=corr_params,
+ )
+ expected_results = {
+ "TT-2": ["GH-2", 3],
+ "TT-3": ["GH-3", 1],
+ "TT-1": ["GH-1", 0],
+ }
+
+ self.assertTrue(isinstance(sorted_results, OrderedDict))
+ self.assertEqual(dict(sorted_results), expected_results)
diff --git a/gn2/tests/unit/wqflask/api/test_gen_menu.py b/gn2/tests/unit/wqflask/api/test_gen_menu.py
new file mode 100644
index 00000000..a6081e99
--- /dev/null
+++ b/gn2/tests/unit/wqflask/api/test_gen_menu.py
@@ -0,0 +1,423 @@
+"""Test cases for wqflask.api.gen_menu"""
+import unittest
+from unittest import mock
+
+from gn2.wqflask.api.gen_menu import gen_dropdown_json
+from gn2.wqflask.api.gen_menu import get_groups
+from gn2.wqflask.api.gen_menu import get_types
+from gn2.wqflask.api.gen_menu import get_datasets
+from gn2.wqflask.api.gen_menu import phenotypes_exist
+from gn2.wqflask.api.gen_menu import genotypes_exist
+from gn2.wqflask.api.gen_menu import build_datasets
+from gn2.wqflask.api.gen_menu import build_types
+
+
+class TestGenMenu(unittest.TestCase):
+ """Tests for the gen_menu module"""
+
+ def setUp(self):
+ self.test_group = {
+ 'mouse': [
+ ['H_T1',
+ 'H_T',
+ 'Family:DescriptionA'
+ ],
+ ['H_T2', "H_T'", 'Family:None']
+ ],
+ 'human': [
+ ['BXD', 'BXD', 'Family:None'],
+ ['HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
+ 'Family:Test']
+ ]
+ }
+
+ self.test_type = {
+ 'mouse': {
+ 'H_T2': [('Phenotypes',
+ 'Traits and Cofactors',
+ 'Phenotypes'),
+ ('Genotypes',
+ 'DNA Markers and SNPs',
+ 'Genotypes'),
+ ['M', 'M', 'Molecular Trait Datasets']],
+ 'H_T1': [('Phenotypes',
+ 'Traits and Cofactors',
+ 'Phenotypes'),
+ ('Genotypes',
+ 'DNA Markers and SNPs',
+ 'Genotypes'),
+ ['M', 'M', 'Molecular Trait Datasets']]
+ },
+ 'human': {
+ 'HLC': [('Phenotypes',
+ 'Traits and Cofactors',
+ 'Phenotypes'),
+ ('Genotypes',
+ 'DNA Markers and SNPs',
+ 'Genotypes'),
+ ['M', 'M', 'Molecular Trait Datasets']],
+ 'BXD': [('Phenotypes',
+ 'Traits and Cofactors',
+ 'Phenotypes'),
+ ('Genotypes',
+ 'DNA Markers and SNPs',
+ 'Genotypes'),
+ ['M', 'M', 'Molecular Trait Datasets']]
+ }
+ }
+
+ def test_get_groups(self):
+ """Test that species groups are grouped correctly"""
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as cursor:
+ cursor.fetchall.side_effect = [
+ # Mouse
+ (('BXD', 'BXD', None),
+ ('HLC', ('Liver: Normal Gene Expression '
+ 'with Genotypes (Merck)'),
+ 'Test')),
+ # Human
+ (('H_T1', "H_T", "DescriptionA"),
+ ('H_T2', "H_T'", None))
+ ]
+ self.assertEqual(get_groups([["human", "Human"],
+ ["mouse", "Mouse"]],
+ db_mock),
+ self.test_group)
+
+ for name in ["mouse", "human"]:
+ cursor.execute.assert_any_call(
+ ("SELECT InbredSet.Name, InbredSet.FullName, "
+ "IFNULL(InbredSet.Family, 'None') "
+ "FROM InbredSet, Species WHERE Species.Name "
+ "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by "
+ "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, "
+ "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, "
+ "InbredSet.FullName) ASC, InbredSet.FullName ASC, "
+ "InbredSet.MenuOrderId ASC").format(name)
+ )
+
+ def test_phenotypes_exist_called_with_correct_query(self):
+ """Test that phenotypes_exist is called with the correct query"""
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as cursor:
+ cursor.fetchone.return_value = None
+ phenotypes_exist("test", db_mock)
+ cursor.execute.assert_called_with(
+ "SELECT Name FROM PublishFreeze "
+ "WHERE PublishFreeze.Name = 'testPublish'"
+ )
+
+ def test_phenotypes_exist_with_falsy_values(self):
+ """Test that phenotype check returns correctly when given
+ a None value"""
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as cursor:
+ for x in [None, False, (), [], ""]:
+ cursor.fetchone.return_value = x
+ self.assertFalse(phenotypes_exist("test", db_mock))
+
+ def test_phenotypes_exist_with_truthy_value(self):
+ """Test that phenotype check returns correctly when given Truthy"""
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as conn:
+ with conn.cursor() as cursor:
+ for x in ["x", ("result"), ["result"], [1]]:
+ cursor.fetchone.return_value = (x)
+ self.assertTrue(phenotypes_exist("test", db_mock))
+
+ def test_genotypes_exist_called_with_correct_query(self):
+ """Test that genotypes_exist is called with the correct query"""
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as cursor:
+ cursor.fetchone.return_value = None
+ genotypes_exist("test", db_mock)
+ cursor.execute.assert_called_with(
+ "SELECT Name FROM GenoFreeze WHERE "
+ "GenoFreeze.Name = 'testGeno'"
+ )
+
+ def test_genotypes_exist_with_falsy_values(self):
+ """Test that genotype check returns correctly when given a None value
+
+ """
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as cursor:
+ for x in [None, False, (), [], ""]:
+ cursor.fetchone.return_value = x
+ self.assertFalse(genotypes_exist("test", db_mock))
+
+ def test_genotypes_exist_with_truthy_value(self):
+ """Test that genotype check returns correctly when given Truthy """
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as cursor:
+ for x in ["x", ("result"), ["result"], [1]]:
+ cursor.fetchone.return_value = (x)
+ self.assertTrue(phenotypes_exist("test", db_mock))
+
+ def test_build_datasets_with_type_phenotypes(self):
+ """Test that correct dataset is returned for a phenotype type"""
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as cursor:
+ cursor.fetchall.return_value = (
+ (602, "BXDPublish", "BXD Published Phenotypes"),
+ )
+ self.assertEqual(build_datasets("Mouse", "BXD",
+ "Phenotypes", db_mock),
+ [['602', "BXDPublish",
+ "BXD Published Phenotypes"]])
+ cursor.execute.assert_called_with(
+ "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, "
+ + "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, "
+ + "InbredSet WHERE InbredSet.Name = 'BXD' AND "
+ + "PublishFreeze.InbredSetId = InbredSet.Id AND "
+ + "InfoFiles.InfoPageName = PublishFreeze.Name "
+ + "ORDER BY PublishFreeze.CreateTime ASC"
+ )
+ self.assertEqual(build_datasets("Mouse", "MDP",
+ "Phenotypes", db_mock),
+ [['602', "BXDPublish",
+ "Mouse Phenome Database"]])
+
+ cursor.fetchall.return_value = ()
+ cursor.fetchone.return_value = (
+ "BXDPublish", "Mouse Phenome Database"
+ )
+ self.assertEqual(build_datasets("Mouse", "MDP",
+ "Phenotypes", db_mock),
+ [["None", "BXDPublish",
+ "Mouse Phenome Database"]])
+
+ def test_build_datasets_with_type_phenotypes_and_no_results(self):
+ """Test that correct dataset is returned for a phenotype type with no
+ results
+
+ """
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as cursor:
+ cursor.fetchall.return_value = None
+ cursor.fetchone.return_value = (121,
+ "text value")
+ self.assertEqual(build_datasets("Mouse", "BXD",
+ "Phenotypes", db_mock),
+ [["None", "121",
+ "text value"]])
+ cursor.execute.assert_called_with(
+ "SELECT PublishFreeze.Name, PublishFreeze.FullName "
+ "FROM PublishFreeze, InbredSet "
+ "WHERE InbredSet.Name = 'BXD' AND "
+ "PublishFreeze.InbredSetId = InbredSet.Id "
+ "ORDER BY PublishFreeze.CreateTime ASC"
+ )
+
+ def test_build_datasets_with_type_genotypes(self):
+ """Test that correct dataset is returned for a phenotype type"""
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as cursor:
+ cursor.fetchone.return_value = (
+ 635, "HLCPublish", "HLC Published Genotypes"
+ )
+ self.assertEqual(build_datasets("Mouse", "HLC",
+ "Genotypes", db_mock),
+ [["635", "HLCGeno", "HLC Genotypes"]])
+ cursor.execute.assert_called_with(
+ "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, "
+ "GenoFreeze, InbredSet WHERE InbredSet.Name = 'HLC' AND "
+ "GenoFreeze.InbredSetId = InbredSet.Id AND "
+ "InfoFiles.InfoPageName = GenoFreeze.ShortName "
+ "ORDER BY GenoFreeze.CreateTime DESC"
+ )
+ cursor.fetchone.return_value = ()
+ self.assertEqual(build_datasets("Mouse", "HLC",
+ "Genotypes", db_mock),
+ [["None", "HLCGeno", "HLC Genotypes"]])
+
+ def test_build_datasets_with_type_mrna(self):
+ """Test that correct dataset is returned for a mRNA
+ expression/ Probeset"""
+ db_mock = mock.MagicMock()
+ with db_mock.cursor() as cursor:
+ cursor.fetchall.return_value = (
+ (112, "HC_M2_0606_P",
+ "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
+ self.assertEqual(build_datasets("Mouse",
+ "HLC", "mRNA", db_mock),
+ [["112", 'HC_M2_0606_P',
+ "Hippocampus Consortium M430v2 (Jun06) PDNN"
+ ]])
+ cursor.execute.assert_called_once_with(
+ "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, "
+ "ProbeSetFreeze.FullName FROM ProbeSetFreeze, "
+ "ProbeFreeze, InbredSet, Tissue, Species WHERE "
+ "Species.Name = 'Mouse' AND Species.Id = "
+ "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND "
+ "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id AND "
+ "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = "
+ "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id AND "
+ "ProbeSetFreeze.public > 0 "
+ "ORDER BY -ProbeSetFreeze.OrderList DESC, "
+ "ProbeSetFreeze.CreateTime DESC")
+
+ @mock.patch('wqflask.api.gen_menu.build_datasets')
+ def test_build_types(self, datasets_mock):
+ """Test that correct tissue metadata is returned"""
+ db_mock = mock.MagicMock()
+ datasets_mock.return_value = [
+ ["112", 'HC_M2_0606_P',
+ "Hippocampus Consortium M430v2 (Jun06) PDNN"]
+ ]
+ with db_mock.cursor() as cursor:
+ cursor.fetchall.return_value = (
+ ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
+ )
+ self.assertEqual(build_types('mouse', 'random group', db_mock),
+ [['M', 'M', 'Molecular Traits'],
+ ['H', 'H', 'Molecular Traits'],
+ ['R', 'R', 'Molecular Traits']])
+ cursor.execute.assert_called_once_with(
+ "SELECT DISTINCT Tissue.Name "
+ "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, "
+ "Tissue, Species WHERE Species.Name = 'mouse' "
+ "AND Species.Id = InbredSet.SpeciesId AND "
+ "InbredSet.Name = 'random group' AND "
+ "ProbeFreeze.TissueId = Tissue.Id AND "
+ "ProbeFreeze.InbredSetId = InbredSet.Id AND "
+ "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id "
+ "ORDER BY Tissue.Name"
+ )
+
+ @mock.patch('wqflask.api.gen_menu.build_types')
+ @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+ @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+ def test_get_types_with_existing_genotype_and_phenotypes(
+ self,
+ phenotypes_exist_mock,
+ genotypes_exist_mock,
+ build_types_mock):
+ """Test that build types are constructed correctly if phenotypes and genotypes
+ exist
+
+ """
+ phenotypes_exist_mock.return_value = True
+ genotypes_exist_mock.return_value = True
+
+ expected_result = self.test_type
+
+ build_types_mock.return_value = [
+ ['M', 'M', 'Molecular Trait Datasets']
+ ]
+ self.assertEqual(get_types(self.test_group,
+ mock.MagicMock()),
+ expected_result)
+
+ @mock.patch('wqflask.api.gen_menu.build_types')
+ @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+ @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+ def test_get_types_with_buildtype_and_non_existent_genotype_and_phenotypes(
+ self,
+ phenotypes_exist_mock,
+ genotypes_exist_mock,
+ build_types_mock):
+ """Test that build types are constructed correctly if phenotypes_exist and
+ genotypes_exist are false but build_type is falsy
+
+ """
+ phenotypes_exist_mock.return_value = False
+ genotypes_exist_mock.return_value = False
+
+ build_types_mock.return_value = []
+ self.assertEqual(get_types(self.test_group, mock.MagicMock()),
+ {'mouse': {}, 'human': {}})
+
+ @mock.patch('wqflask.api.gen_menu.build_types')
+ @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+ @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+ def test_get_types_with_non_existent_genotype_phenotypes_and_buildtype(
+ self,
+ phenotypes_exist_mock,
+ genotypes_exist_mock,
+ build_types_mock):
+ """Test that build types are constructed correctly if phenotypes_exist,
+ genotypes_exist and build_types are truthy
+
+ """
+ phenotypes_exist_mock.return_value = False
+ genotypes_exist_mock.return_value = False
+
+ build_types_mock.return_value = [
+ ['M', 'M', 'Molecular Trait Datasets']
+ ]
+ expected_result = {
+ 'mouse': {
+ 'H_T2': [['M', 'M', 'Molecular Trait Datasets']],
+ 'H_T1': [['M', 'M', 'Molecular Trait Datasets']]},
+ 'human': {
+ 'HLC': [['M', 'M', 'Molecular Trait Datasets']],
+ 'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
+ self.assertEqual(get_types(self.test_group, mock.MagicMock()),
+ expected_result)
+
+ @mock.patch('wqflask.api.gen_menu.build_datasets')
+ def test_get_datasets_with_existent_datasets(self,
+ build_datasets_mock):
+ """Test correct dataset is returned with existent build_datasets"""
+ build_datasets_mock.return_value = "Test"
+ expected_result = {
+ 'mouse': {
+ 'H_T2': {'Genotypes': 'Test',
+ 'M': 'Test',
+ 'Phenotypes': 'Test'},
+ 'H_T1': {'Genotypes': 'Test',
+ 'M': 'Test',
+ 'Phenotypes': 'Test'}},
+ 'human': {'HLC': {'Genotypes': 'Test',
+ 'M': 'Test',
+ 'Phenotypes': 'Test'},
+ 'BXD': {'Genotypes': 'Test',
+ 'M': 'Test',
+ 'Phenotypes': 'Test'}}}
+ self.assertEqual(get_datasets(self.test_type, mock.MagicMock()),
+ expected_result)
+
+ @mock.patch('wqflask.api.gen_menu.build_datasets')
+ def test_get_datasets_with_non_existent_datasets(self,
+ build_datasets_mock):
+ """Test correct dataset is returned with non-existent build_datasets"""
+ build_datasets_mock.return_value = None
+ expected_result = {
+ 'mouse': {
+ 'H_T2': {},
+ 'H_T1': {}},
+ 'human': {'HLC': {},
+ 'BXD': {}}}
+ self.assertEqual(get_datasets(self.test_type, mock.MagicMock()),
+ expected_result)
+
+ @mock.patch('wqflask.api.gen_menu.get_datasets')
+ @mock.patch('wqflask.api.gen_menu.get_types')
+ @mock.patch('wqflask.api.gen_menu.get_groups')
+ @mock.patch('wqflask.api.gen_menu.get_all_species')
+ def test_gen_dropdown_json(self,
+ species_mock,
+ groups_mock,
+ types_mock,
+ datasets_mock):
+ "Test that the correct dictionary is constructed properly"
+ species_mock.return_value = ("speciesA speciesB speciesC speciesD"
+ .split(" "))
+ datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
+ .split(" "))
+ groups_mock.return_value = ("groupA groupB groupC groupD"
+ .split(" "))
+ types_mock.return_value = ("typeA typeB typeC typeD"
+ .split(" "))
+ datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
+ .split(" "))
+
+ expected_result = {
+ 'datasets': ['datasetA', 'datasetB', 'datasetC', 'datasetD'],
+ 'types': ['typeA', 'typeB', 'typeC', 'typeD'],
+ 'groups': ['groupA', 'groupB', 'groupC', 'groupD'],
+ 'species': ['speciesA', 'speciesB', 'speciesC', 'speciesD']}
+
+ self.assertEqual(gen_dropdown_json(mock.MagicMock()), expected_result)
diff --git a/gn2/tests/unit/wqflask/api/test_mapping.py b/gn2/tests/unit/wqflask/api/test_mapping.py
new file mode 100644
index 00000000..1553cbf6
--- /dev/null
+++ b/gn2/tests/unit/wqflask/api/test_mapping.py
@@ -0,0 +1,113 @@
+import unittest
+from unittest import mock
+from gn2.wqflask.api.mapping import initialize_parameters
+from gn2.wqflask.api.mapping import do_mapping_for_api
+
+
+class AttributeSetter:
+ def __init__(self, obj):
+ for key, value in obj.items():
+ setattr(self, key, value)
+
+
+class MockGroup(AttributeSetter):
+ def get_marker(self):
+ self.markers = []
+
+
+class TestMapping(unittest.TestCase):
+
+ def test_initialize_parameters(self):
+ expected_results = {
+ "format": "json",
+ "limit_to": False,
+ "mapping_method": "gemma",
+ "maf": 0.01,
+ "use_loco": True,
+ "num_perm": 0,
+ "perm_check": False,
+ "transform": False,
+ "genofile": False
+ }
+
+ results = initialize_parameters(
+ start_vars={}, dataset={}, this_trait={})
+ self.assertEqual(results, expected_results)
+
+ start_vars = {
+ "format": "F1",
+ "limit_to": "1",
+ "mapping_method": "rqtl",
+ "control_marker": True,
+ "pair_scan": "true",
+ "interval_mapping": "true",
+ "use_loco": "true",
+ "num_perm": "14",
+ "transform": "qnorm",
+ "genofile": "BXD.8.geno"
+ }
+
+ results_2 = initialize_parameters(
+ start_vars=start_vars, dataset={}, this_trait={})
+ expected_results = {
+ "format": "F1",
+ "limit_to": 1,
+ "mapping_method": "gemma",
+ "maf": 0.01,
+ "use_loco": True,
+ "num_perm": 14,
+ "perm_check": "ON",
+ "transform": "qnorm",
+ "genofile": "BXD.8.geno"
+ }
+
+ self.assertEqual(results_2, expected_results)
+
+ @mock.patch("wqflask.api.mapping.rqtl_mapping.run_rqtl")
+ @mock.patch("wqflask.api.mapping.gemma_mapping.run_gemma")
+ @mock.patch("wqflask.api.mapping.initialize_parameters")
+ @mock.patch("wqflask.api.mapping.retrieve_sample_data")
+ @mock.patch("wqflask.api.mapping.create_trait")
+ @mock.patch("wqflask.api.mapping.data_set.create_dataset")
+ def test_do_mapping_for_api(self, mock_create_dataset, mock_trait, mock_retrieve_sample, mock_param, run_gemma, run_rqtl_geno):
+ start_vars = {
+ "db": "Temp",
+ "trait_id": "dewf3232rff2",
+ "format": "F1",
+ "mapping_method": "gemma",
+ "use_loco": True
+
+ }
+ sampleList = ["S1", "S2", "S3", "S4"]
+ samplelist = ["S1", "S2", "S4"]
+ dataset = AttributeSetter({"group": samplelist})
+ this_trait = AttributeSetter({})
+ trait_data = AttributeSetter({
+ "data": {
+ "item1": AttributeSetter({"name": "S1", "value": "S1_value"}),
+ "item2": AttributeSetter({"name": "S2", "value": "S2_value"}),
+ "item3": AttributeSetter({"name": "S3", "value": "S3_value"}),
+
+ }
+ })
+ trait = AttributeSetter({
+ "data": trait_data
+ })
+
+ dataset.return_value = dataset
+ mock_trait.return_value = this_trait
+
+ mock_retrieve_sample.return_value = trait
+ mock_param.return_value = {
+ "format": "F1",
+ "limit_to": False,
+ "mapping_method": "gemma",
+ "maf": 0.01,
+ "use_loco": "True",
+ "num_perm": 14,
+ "perm_check": "ON"
+ }
+
+ run_gemma.return_value = ["results"]
+ results = do_mapping_for_api(start_vars=start_vars)
+ self.assertEqual(results, ("results", None))
diff --git a/gn2/tests/unit/wqflask/api/test_markdown_routes.py b/gn2/tests/unit/wqflask/api/test_markdown_routes.py
new file mode 100644
index 00000000..f0f93bc1
--- /dev/null
+++ b/gn2/tests/unit/wqflask/api/test_markdown_routes.py
@@ -0,0 +1,54 @@
+"""Test functions for wqflask/api/markdown.py"""
+
+import unittest
+from unittest import mock
+
+from dataclasses import dataclass
+from gn2.wqflask.api.markdown import render_markdown
+
+
+@dataclass
+class MockRequests404:
+ status_code: int = 404
+
+
+@dataclass
+class MockRequests200:
+ status_code: int = 200
+ content: str = b"""
+# Glossary
+This is some content
+
+## Sub-heading
+This is another sub-heading"""
+
+
+class TestMarkdownRoutesFunctions(unittest.TestCase):
+ """Test cases for functions in markdown"""
+
+ @mock.patch('wqflask.api.markdown.requests.get')
+ def test_render_markdown_when_fetching_locally(self, requests_mock):
+ requests_mock.return_value = MockRequests404()
+ markdown_content = render_markdown("general/glossary/glossary.md")
+ requests_mock.assert_called_with(
+ "https://raw.githubusercontent.com"
+ "/genenetwork/gn-docs/"
+ "master/general/"
+ "glossary/glossary.md")
+ self.assertRegex(markdown_content,
+ "Content for general/glossary/glossary.md not available.")
+
+ @mock.patch('wqflask.api.markdown.requests.get')
+ def test_render_markdown_when_fetching_remotely(self, requests_mock):
+ requests_mock.return_value = MockRequests200()
+ markdown_content = render_markdown("general/glossary/glossary.md")
+ requests_mock.assert_called_with(
+ "https://raw.githubusercontent.com"
+ "/genenetwork/gn-docs/"
+ "master/general/"
+ "glossary/glossary.md")
+ self.assertEqual("""Glossary
+This is some content
+Sub-heading
+This is another sub-heading
""",
+ markdown_content)
diff --git a/gn2/tests/unit/wqflask/correlation/__init__.py b/gn2/tests/unit/wqflask/correlation/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/gn2/tests/unit/wqflask/correlation/test_correlation_functions.py b/gn2/tests/unit/wqflask/correlation/test_correlation_functions.py
new file mode 100644
index 00000000..c0f57141
--- /dev/null
+++ b/gn2/tests/unit/wqflask/correlation/test_correlation_functions.py
@@ -0,0 +1,21 @@
+"""module contains tests for correlation functions"""
+
+import unittest
+from unittest import mock
+
+from gn2.wqflask.correlation.correlation_functions import get_trait_symbol_and_tissue_values
+from gn2.wqflask.correlation.correlation_functions import cal_zero_order_corr_for_tiss
+
+
+def test_tissue_corr_computation(mocker):
+ """Test for cal_zero_order_corr_for_tiss"""
+ primary_values = [9.288, 9.313, 8.988, 9.660, 8.21]
+ target_values = [9.586, 8.498, 9.362, 8.820, 8.786]
+ _m = mocker.patch(("wqflask.correlation.correlation_functions."
+ "compute_corr_coeff_p_value"),
+ return_value=(0.51, 0.7))
+ results = cal_zero_order_corr_for_tiss(primary_values, target_values)
+ _m.assert_called_once_with(
+ primary_values=primary_values, target_values=target_values,
+ corr_method="pearson")
+ assert len(results) == 3
diff --git a/gn2/tests/unit/wqflask/correlation/test_correlation_gn3.py b/gn2/tests/unit/wqflask/correlation/test_correlation_gn3.py
new file mode 100644
index 00000000..432dbc95
--- /dev/null
+++ b/gn2/tests/unit/wqflask/correlation/test_correlation_gn3.py
@@ -0,0 +1,14 @@
+"""this module contains tests for code used in integrating to gn3 api"""
+from unittest import TestCase
+from gn2.base.data_set import create_dataset
+
+class TestCorrelation(TestCase):
+
+ def test_create_dataset(self):
+ """test for creating datasets"""
+
+ pass
+ def test_fetch_dataset_info(self):
+ """test for fetching dataset info data"""
+
+ pass
diff --git a/gn2/tests/unit/wqflask/correlation/test_show_corr_results.py b/gn2/tests/unit/wqflask/correlation/test_show_corr_results.py
new file mode 100644
index 00000000..b1459dd9
--- /dev/null
+++ b/gn2/tests/unit/wqflask/correlation/test_show_corr_results.py
@@ -0,0 +1,42 @@
+import unittest
+from unittest import mock
+from gn2.wqflask.correlation.show_corr_results import get_header_fields
+
+
+class AttributeSetter:
+ def __init__(self, trait_obj):
+ for key, value in trait_obj.items():
+ setattr(self, key, value)
+
+
+class TestShowCorrResults(unittest.TestCase):
+ def test_get_header_fields(self):
+ expected = [
+ ['Index',
+ 'Record',
+ 'Symbol',
+ 'Description',
+ 'Location',
+ 'Mean',
+ 'Sample rho',
+ 'N',
+ 'Sample p(rho)',
+ 'Lit rho',
+ 'Tissue rho',
+ 'Tissue p(rho)',
+ 'Max LRS',
+ 'Max LRS Location',
+ 'Additive Effect'],
+
+ ['Index',
+ 'ID',
+ 'Location',
+ 'Sample r',
+ 'N',
+ 'Sample p(r)']
+
+ ]
+ result1 = get_header_fields("ProbeSet", "spearman")
+ result2 = get_header_fields("Other", "Other")
+ self.assertEqual(result1, expected[0])
+ self.assertEqual(result2, expected[1])
diff --git a/gn2/tests/unit/wqflask/marker_regression/__init__.py b/gn2/tests/unit/wqflask/marker_regression/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/gn2/tests/unit/wqflask/marker_regression/genotype/bimbam/file_geno.txt b/gn2/tests/unit/wqflask/marker_regression/genotype/bimbam/file_geno.txt
new file mode 100644
index 00000000..e69de29b
diff --git a/gn2/tests/unit/wqflask/marker_regression/genotype/bimbam/file_snps.txt b/gn2/tests/unit/wqflask/marker_regression/genotype/bimbam/file_snps.txt
new file mode 100644
index 00000000..e69de29b
diff --git a/gn2/tests/unit/wqflask/marker_regression/test_display_mapping_results.py b/gn2/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
new file mode 100644
index 00000000..580d79cf
--- /dev/null
+++ b/gn2/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
@@ -0,0 +1,159 @@
+import unittest
+
+import htmlgen as HT
+from gn2.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")),
+ ("""![random]()
""")
+ )
+
+ 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", ""),
+ (""""""))
+ 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", ""), (
+ """"""))
+
+ 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),
+ """"""
+ )
+ test_p_element.append(HtmlGenWrapper.create_br_tag())
+ test_p_element.append(par_text)
+ self.assertEqual(
+ str(test_p_element),
+ """
{}
""".format(par_text)
+ )
+
+ def test_create_br_tag(self):
+ """Test HT.BR() method"""
+ self.assertEqual(str(HtmlGenWrapper.create_br_tag()),
+ "
")
+
+ 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", ""),
+ (""""""))
+
+ def test_create_map_tag(self):
+ """Test HT.Map method"""
+ self.assertEqual(str(HtmlGenWrapper.create_map_tag(
+ name="WebqTLImageMap")).replace("\n", ""),
+ """""")
+ 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", ""),
+ (""""""))
+
+ 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", ""),
+ (""""""))
+
+ 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", ""),
+ """test""")
diff --git a/gn2/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/gn2/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
new file mode 100644
index 00000000..26f0c50a
--- /dev/null
+++ b/gn2/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -0,0 +1,188 @@
+# test for wqflask/marker_regression/gemma_mapping.py
+import os
+import unittest
+import random
+from unittest import mock
+from gn2.wqflask.marker_regression.gemma_mapping import run_gemma
+from gn2.wqflask.marker_regression.gemma_mapping import gen_pheno_txt_file
+from gn2.wqflask.marker_regression.gemma_mapping import gen_covariates_file
+from gn2.wqflask.marker_regression.gemma_mapping import parse_loco_output
+
+
+class AttributeSetter:
+ def __init__(self, obj):
+ for key, val in obj.items():
+ setattr(self, key, val)
+
+
+class MockGroup(AttributeSetter):
+ def get_samplelist(self, redis_conn):
+ return None
+
+
+class TestGemmaMapping(unittest.TestCase):
+
+ @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
+ def test_run_gemma_firstrun_set_false(self, mock_parse_loco):
+ """add tests for gemma function where first run is set to false"""
+ dataset = AttributeSetter(
+ {"group": AttributeSetter({"genofile": "genofile.geno"})})
+
+ output_file = "file1"
+ mock_parse_loco.return_value = []
+ this_trait = AttributeSetter({"name": "t1"})
+
+ result = run_gemma(this_trait=this_trait, this_dataset=dataset, samples=[], vals=[
+ ], covariates="", use_loco=True, first_run=False, output_files=output_file)
+
+ expected_results = ([], "file1")
+ self.assertEqual(expected_results, result)
+
+ @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMAOPTS", "-debug")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMA_WRAPPER_COMMAND", "ghc")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR",
+ os.path.join(os.path.dirname(__file__), "user/data"))
+ @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.gen_covariates_file")
+ @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.os")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
+ def test_run_gemma_firstrun_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files, mock_parse_loco):
+ """add tests for run_gemma where first run is set to true"""
+ this_chromosomes = {}
+ for i in range(1, 5):
+ this_chromosomes[f'CH{i}'] = (AttributeSetter({"name": f"CH{i}"}))
+ chromosomes = AttributeSetter({"chromosomes": lambda cursor: this_chromosomes})
+
+ dataset_group = MockGroup(
+ {"name": "GP1", "genofile": "file_geno"})
+ dataset = AttributeSetter({"group": dataset_group, "name": "dataset1_name",
+ "species": AttributeSetter({"chromosomes": chromosomes})})
+ trait = AttributeSetter({"name": "trait1"})
+ samples = []
+ mock_gen_pheno_txt.return_value = None
+ mock_os.path.isfile.return_value = True
+ mock_gen_covar.return_value = None
+ mock_choice.return_value = "R"
+ mock_flat_files.return_value = os.path.join(
+ os.path.dirname(__file__), "genotype/bimbam")
+ mock_parse_loco.return_value = []
+ results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[
+ ], vals=[], covariates="", use_loco=True)
+ mock_gen_pheno_txt.assert_called_once()
+ mock_parse_loco.assert_called_once_with(
+ dataset, "GP1_GWA_RRRRRR", True)
+ mock_os.path.isfile.assert_called_once_with(
+ ('/home/user/imgfile_output.assoc.txt'))
+ self.assertEqual(results, ([], "GP1_GWA_RRRRRR"))
+
+ @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data")
+ def test_gen_pheno_txt_file(self):
+ """add tests for generating pheno txt file"""
+ with mock.patch("builtins.open", mock.mock_open())as mock_open:
+ gen_pheno_txt_file(
+ this_dataset=AttributeSetter({"name": "A"}),
+ genofile_name="", vals=[
+ "x", "w", "q", "we", "R"])
+ mock_open.assert_called_once_with(
+ '/home/user/data/gn2/PHENO_KiAEKlCvM6iGTM9Kh_TAlQ.txt', 'w')
+ filehandler = mock_open()
+ values = ["x", "w", "q", "we", "R"]
+ write_calls = [mock.call('NA\n'), mock.call('w\n'), mock.call(
+ 'q\n'), mock.call('we\n'), mock.call('R\n')]
+
+ filehandler.write.assert_has_calls(write_calls)
+
+ @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.create_trait")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.create_dataset")
+ def test_gen_covariates_file(self, create_dataset, create_trait, flat_files):
+ """add tests for generating covariates files"""
+ covariates = "X1:X2,Y1:Y2,M1:M3,V1:V2"
+ samplelist = ["X1", "X2", "X3", "X4"]
+ create_dataset_side_effect = []
+ create_trait_side_effect = []
+
+ for i in range(4):
+ create_dataset_side_effect.append(
+ AttributeSetter({"name": f'name_{i}'}))
+ create_trait_side_effect.append(
+ AttributeSetter({"data": [f'data_{i}']}))
+
+ create_dataset.side_effect = create_trait_side_effect
+ create_trait.side_effect = create_trait_side_effect
+
+ group = MockGroup({"name": "group_X", "samplelist": samplelist})
+ this_dataset = AttributeSetter({"group": group, "name": "dataset1_name"})
+ flat_files.return_value = "Home/Genenetwork"
+
+ with mock.patch("builtins.open", mock.mock_open())as mock_open:
+ gen_covariates_file(this_dataset=this_dataset, covariates=covariates,
+ samples=["x1", "x2", "X3"])
+
+ create_dataset.assert_has_calls(
+ [mock.call('X2'), mock.call('Y2'), mock.call('M3'), mock.call('V2')])
+ mock_calls = []
+ trait_names = ["X1", "Y1", "M1", "V1"]
+
+ for i, trait in enumerate(create_trait_side_effect):
+ mock_calls.append(
+ mock.call(dataset=trait, name=trait_names[i], cellid=None))
+
+ create_trait.assert_has_calls(mock_calls)
+
+ flat_files.assert_called_once_with('mapping')
+ mock_open.assert_called_once_with(
+ 'Home/Genenetwork/COVAR_npKxIOnq3azWdgYixtd9IQ.txt', 'w')
+ filehandler = mock_open()
+ filehandler.write.assert_has_calls([mock.call(
+ '-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('\n')])
+
+ @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.os")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.json")
+ def test_parse_loco_outputfile_found(self, mock_json, mock_os):
+ """add tests for parse loco output file found"""
+ mock_json.load.return_value = {
+ "files": [["file_name", "user", "~/file1"],
+ ["file_name", "user", "~/file2"]]
+ }
+ return_file = """X/Y\tM1\t28.457155\tQ\tE\tA\tMMB\t23.3\tW\t0.9\t0.85\t
+chr4\tM2\t12\tQ\tE\tMMB\tR\t24\tW\t0.87\t0.5
+Y\tM4\t12\tQ\tE\tMMB\tR\t11.6\tW\t0.21\t0.7
+X\tM5\t12\tQ\tE\tMMB\tR\t21.1\tW\t0.65\t0.6"""
+
+ return_file_2 = """chr\tother\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5\t0.4"""
+ mock_os.path.isfile.return_value = True
+ file_to_write = """{"files":["file_1","file_2"]}"""
+ with mock.patch("builtins.open") as mock_open:
+
+ handles = (mock.mock_open(read_data="gwas").return_value, mock.mock_open(
+ read_data=return_file).return_value, mock.mock_open(read_data=return_file_2).return_value)
+ mock_open.side_effect = handles
+ results = parse_loco_output(
+ this_dataset={}, gwa_output_filename=".xw/")
+ expected_results = [
+ {'name': 'M1', 'chr': 'X/Y', 'Mb': 2.8457155e-05, 'p_value': 0.85,
+ 'additive': -11.65, 'lod_score': 0.07058107428570727},
+ {'name': 'M2', 'chr': 4, 'Mb': 1.2e-05, 'p_value': 0.5,
+ 'additive': -12.0, 'lod_score': 0.3010299956639812},
+ {'name': 'M4', 'chr': 'Y', 'Mb': 1.2e-05, 'p_value': 0.7,
+ 'additive': -5.8, 'lod_score': 0.1549019599857432},
+ {'name': 'M5', 'chr': 'X', 'Mb': 1.2e-05, 'p_value': 0.6, 'additive': -10.55, 'lod_score': 0.22184874961635637}]
+ self.assertEqual(expected_results, results)
+
+ @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
+ @mock.patch("wqflask.marker_regression.gemma_mapping.os")
+ def test_parse_loco_outputfile_not_found(self, mock_os):
+ """add tests for parse loco output where output file not found"""
+
+ mock_os.path.isfile.return_value = False
+ file_to_write = """{"files":["file_1","file_2"]}"""
+
+ with mock.patch("builtins.open", mock.mock_open(read_data=file_to_write)) as mock_open:
+ results = parse_loco_output(
+ this_dataset={}, gwa_output_filename=".xw/")
+ self.assertEqual(results, [])
diff --git a/gn2/tests/unit/wqflask/marker_regression/test_plink_mapping.py b/gn2/tests/unit/wqflask/marker_regression/test_plink_mapping.py
new file mode 100644
index 00000000..4c13b907
--- /dev/null
+++ b/gn2/tests/unit/wqflask/marker_regression/test_plink_mapping.py
@@ -0,0 +1,86 @@
+# test for wqflask/marker_regression/plink_mapping.py
+import unittest
+from unittest import mock
+from gn2.wqflask.marker_regression.plink_mapping import build_line_list
+from gn2.wqflask.marker_regression.plink_mapping import get_samples_from_ped_file
+from gn2.wqflask.marker_regression.plink_mapping import flat_files
+from gn2.wqflask.marker_regression.plink_mapping import gen_pheno_txt_file_plink
+from gn2.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/gn2/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/gn2/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
new file mode 100644
index 00000000..2268f4cb
--- /dev/null
+++ b/gn2/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -0,0 +1,24 @@
+import unittest
+from unittest import mock
+from gn2.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/gn2/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/gn2/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
new file mode 100644
index 00000000..5cfce28c
--- /dev/null
+++ b/gn2/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -0,0 +1,43 @@
+import unittest
+from unittest import mock
+from dataclasses import dataclass
+
+from gn2.wqflask.marker_regression.rqtl_mapping import run_rqtl
+
+@dataclass
+class MockGroup:
+ name: str
+ genofile: str
+
+@dataclass
+class MockDataset:
+ group: MockGroup
+
+class TestRqtlMapping(unittest.TestCase):
+ """Tests for functions in rqtl_mapping.py"""
+ @mock.patch("wqflask.marker_regression.rqtl_mapping.requests.post")
+ @mock.patch("wqflask.marker_regression.rqtl_mapping.locate")
+ @mock.patch("wqflask.marker_regression.rqtl_mapping.write_phenotype_file")
+ def test_run_rqtl_with_perm(self, mock_write_pheno_file, mock_locate, mock_post):
+ """Test for run_rqtl with permutations > 0"""
+ dataset_group = MockGroup("GP1", "file_geno")
+ dataset = MockDataset(dataset_group)
+
+ mock_write_pheno_file.return_value = "pheno_filename"
+ mock_locate.return_value = "geno_filename"
+ mock_post.return_value = mock.Mock(ok=True)
+ mock_post.return_value.json.return_value = {"perm_results": [],
+ "suggestive": 3,
+ "significant": 4,
+ "results" : []}
+
+ results = run_rqtl(trait_name="the_trait", vals=[], samples=[],
+ dataset=dataset, pair_scan=False, mapping_scale="cM", model="normal", method="hk",
+ num_perm=5, perm_strata_list=[], do_control="false", control_marker="",
+ manhattan_plot=True, cofactors="")
+
+ mock_write_pheno_file.assert_called_once()
+ mock_locate.assert_called_once()
+ mock_post.assert_called_once()
+
+ self.assertEqual(results, ([], 3, 4, []))
diff --git a/gn2/tests/unit/wqflask/marker_regression/test_run_mapping.py b/gn2/tests/unit/wqflask/marker_regression/test_run_mapping.py
new file mode 100644
index 00000000..dd67ce49
--- /dev/null
+++ b/gn2/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -0,0 +1,288 @@
+import unittest
+import datetime
+from unittest import mock
+
+from gn2.wqflask.marker_regression.run_mapping import get_genofile_samplelist
+from gn2.wqflask.marker_regression.run_mapping import geno_db_exists
+from gn2.wqflask.marker_regression.run_mapping import write_input_for_browser
+from gn2.wqflask.marker_regression.run_mapping import export_mapping_results
+from gn2.wqflask.marker_regression.run_mapping import trim_markers_for_figure
+from gn2.wqflask.marker_regression.run_mapping import get_perm_strata
+from gn2.wqflask.marker_regression.run_mapping import get_chr_lengths
+
+
+class AttributeSetter:
+ def __init__(self, obj):
+ for k, v in obj.items():
+ setattr(self, k, v)
+
+
+class MockGroup(AttributeSetter):
+
+ def get_genofiles(self):
+ return [{"location": "~/genofiles/g1_file", "sample_list": ["S1", "S2", "S3", "S4"]}]
+
+
+class TestRunMapping(unittest.TestCase):
+ def setUp(self):
+
+ self.group = MockGroup(
+ {"genofile": "~/genofiles/g1_file", "name": "GP1_", "species": "Human"})
+ chromosomes = {
+ "3": AttributeSetter({
+ "name": "C1",
+ "length": "0.04"
+ }),
+ "4": AttributeSetter({
+ "name": "C2",
+ "length": "0.03"
+ }),
+ "5": AttributeSetter({
+ "name": "C4",
+ "length": "0.01"
+ })
+ }
+ self.dataset = AttributeSetter(
+ {"fullname": "dataset_1", "group": self.group, "type": "ProbeSet"})
+
+ self.chromosomes = AttributeSetter({"chromosomes": lambda cur: chromosomes})
+ self.trait = AttributeSetter(
+ {"symbol": "IGFI", "chr": "X1", "mb": 123313, "display_name": "Test Name"})
+
+ def tearDown(self):
+ self.dataset = AttributeSetter(
+ {"group": {"location": "~/genofiles/g1_file"}})
+
+ def test_get_genofile_samplelist(self):
+
+ results_1 = get_genofile_samplelist(self.dataset)
+ self.assertEqual(results_1, ["S1", "S2", "S3", "S4"])
+ self.group.genofile = "~/genofiles/g2_file"
+ result_2 = get_genofile_samplelist(self.dataset)
+ self.assertEqual(result_2, [])
+
+ @mock.patch("wqflask.marker_regression.run_mapping.data_set")
+ def test_if_geno_db_exists(self, mock_data_set):
+ mock_data_set.create_dataset.side_effect = [
+ AttributeSetter({}), Exception()]
+ results_no_error = geno_db_exists(self.dataset)
+ results_with_error = geno_db_exists(self.dataset)
+
+ self.assertEqual(mock_data_set.create_dataset.call_count, 2)
+ self.assertEqual(results_with_error, "False")
+ self.assertEqual(results_no_error, "True")
+
+ def test_trim_markers_for_figure(self):
+
+ markers = [{
+ "name": "MK1",
+ "chr": "C1",
+ "cM": "1",
+ "Mb": "12000",
+ "genotypes": [],
+ "dominance":"TT",
+ "additive":"VA",
+ "lod_score":0.5
+ },
+ {
+ "name": "MK2",
+ "chr": "C2",
+ "cM": "15",
+ "Mb": "10000",
+ "genotypes": [],
+ "lod_score":0.7
+ },
+ {
+ "name": "MK1",
+ "chr": "C3",
+ "cM": "45",
+ "Mb": "1",
+ "genotypes": [],
+ "dominance":"Tt",
+ "additive":"VE",
+ "lod_score":1
+ }]
+
+ marker_2 = [{
+ "name": "MK1",
+ "chr": "C1",
+ "cM": "1",
+ "Mb": "12000",
+ "genotypes": [],
+ "dominance":"TT",
+ "additive":"VA",
+ "p_wald":4.6
+ }]
+ results = trim_markers_for_figure(markers)
+ result_2 = trim_markers_for_figure(marker_2)
+ expected = [
+ {
+ "name": "MK1",
+ "chr": "C1",
+ "cM": "1",
+ "Mb": "12000",
+ "genotypes": [],
+ "dominance":"TT",
+ "additive":"VA",
+ "lod_score":0.5
+ },
+ {
+ "name": "MK1",
+ "chr": "C3",
+ "cM": "45",
+ "Mb": "1",
+ "genotypes": [],
+ "dominance":"Tt",
+ "additive":"VE",
+ "lod_score":1
+ }
+
+ ]
+ self.assertEqual(results, expected)
+ self.assertEqual(result_2, marker_2)
+
+ def test_export_mapping_results(self):
+ """test for exporting mapping results"""
+ datetime_mock = mock.Mock(wraps=datetime.datetime)
+ datetime_mock.now.return_value = datetime.datetime(
+ 2019, 9, 1, 10, 12, 12)
+
+ markers = [{
+ "name": "MK1",
+ "chr": "C1",
+ "cM": "1",
+ "Mb": "12000",
+ "genotypes": [],
+ "dominance":"TT",
+ "additive":"VA",
+ "lod_score":3
+ },
+ {
+ "name": "MK2",
+ "chr": "C2",
+ "cM": "15",
+ "Mb": "10000",
+ "genotypes": [],
+ "lod_score":7
+ },
+ {
+ "name": "MK1",
+ "chr": "C3",
+ "cM": "45",
+ "Mb": "1",
+ "genotypes": [],
+ "dominance":"Tt",
+ "additive":"VE",
+ "lod_score":7
+ }]
+
+ with mock.patch("builtins.open", mock.mock_open()) as mock_open:
+
+ with mock.patch("wqflask.marker_regression.run_mapping.datetime.datetime", new=datetime_mock):
+ export_mapping_results(dataset=self.dataset, trait=self.trait, markers=markers,
+ results_path="~/results", mapping_method="gemma", mapping_scale="physic",
+ score_type="-logP", transform="qnorm",
+ covariates="Dataset1:Trait1,Dataset2:Trait2",
+ n_samples="100", vals_hash="")
+
+ write_calls = [
+ mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
+ mock.call('Population: Human GP1_\n'), mock.call(
+ 'Data Set: dataset_1\n'),
+ mock.call('Trait: Test Name\n'),
+ mock.call('Trait Hash: \n'),
+ mock.call('N Samples: 100\n'),
+ mock.call('Mapping Tool: gemma\n'),
+ mock.call('Transform - Quantile Normalized\n'),
+ mock.call('Gene Symbol: IGFI\n'), mock.call(
+ 'Location: X1 @ 123313 Mb\n'),
+ mock.call('Cofactors (dataset - trait):\n'),
+ mock.call('Trait1 - Dataset1\n'),
+ mock.call('Trait2 - Dataset2\n'),
+ mock.call('\n'), mock.call('Name,Chr,'),
+ mock.call('Mb,-logP'),
+ mock.call(',Additive'), mock.call(',Dominance'),
+ mock.call('\n'), mock.call('MK1,C1,'),
+ mock.call('12000,'), mock.call('3'),
+ mock.call(',VA'), mock.call(',TT'),
+ mock.call('\n'), mock.call('MK2,C2,'),
+ mock.call('10000,'), mock.call('7'),
+ mock.call('\n'), mock.call('MK1,C3,'),
+ mock.call('1,'), mock.call('7'),
+ mock.call(',VE'), mock.call(',Tt')
+ ]
+ mock_open.assert_called_once_with("~/results", "w+")
+ filehandler = mock_open()
+ filehandler.write.assert_has_calls(write_calls)
+
+ @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
+ def test_write_input_for_browser(self, mock_choice):
+ """test for writing input for browser"""
+ mock_choice.side_effect = ["F", "i", "l", "e", "s", "x"]
+ with mock.patch("builtins.open", mock.mock_open()) as mock_open:
+ expected = ['GP1__Filesx_GWAS', 'GP1__Filesx_ANNOT']
+
+ results = write_input_for_browser(
+ this_dataset=self.dataset, gwas_results={}, annotations={})
+ self.assertEqual(results, expected)
+
+ def test_get_perm_strata(self):
+ categorical_vars = ["C1", "C2", "W1"]
+ used_samples = ["S1", "S2"]
+ sample_list = AttributeSetter({"sample_attribute_values": {
+ "S1": {
+ "c1": "c1_value",
+ "c2": "c2_value",
+ "w1": "w1_value"
+ },
+ "S2": {
+ "w1": "w2_value",
+ "w2": "w2_value"
+ },
+ "S3": {
+
+ "c1": "c1_value",
+ "c2": "c2_value"
+ },
+ }})
+ results = get_perm_strata(this_trait={}, sample_list=sample_list,
+ categorical_vars=categorical_vars, used_samples=used_samples)
+ self.assertEqual(results, [1, 1])
+
+ def test_get_chr_length(self):
+ """test for getting chromosome length"""
+ cursor = mock.MagicMock()
+ chromosomes = AttributeSetter({"chromosomes": self.chromosomes})
+ dataset = AttributeSetter({"species": chromosomes})
+ results = get_chr_lengths(
+ mapping_scale="physic", mapping_method="reaper", dataset=dataset, qtl_results=[])
+ chr_lengths = []
+ for key, chromo in self.chromosomes.chromosomes(cursor).items():
+ chr_lengths.append({"chr": chromo.name, "size": chromo.length})
+
+ self.assertEqual(chr_lengths, results)
+
+ qtl_results = [{
+ "chr": "16",
+ "cM": "0.2"
+ },
+ {
+ "chr": "12",
+ "cM": "0.5"
+ },
+ {
+ "chr": "18",
+ "cM": "0.1"
+ },
+ {
+ "chr": "22",
+ "cM": "0.4"
+ },
+ ]
+
+ result_with_other_mapping_scale = get_chr_lengths(
+ mapping_scale="other", mapping_method="reaper", dataset=dataset, qtl_results=qtl_results)
+ expected_value = [{'chr': '1', 'size': '0'}, {
+ 'chr': '16', 'size': '500000.0'}, {'chr': '18', 'size': '400000.0'}]
+
+ self.assertEqual(result_with_other_mapping_scale, expected_value)
diff --git a/gn2/tests/unit/wqflask/show_trait/__init__.py b/gn2/tests/unit/wqflask/show_trait/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/gn2/tests/unit/wqflask/show_trait/test_export_trait_data.py b/gn2/tests/unit/wqflask/show_trait/test_export_trait_data.py
new file mode 100644
index 00000000..a933d0bf
--- /dev/null
+++ b/gn2/tests/unit/wqflask/show_trait/test_export_trait_data.py
@@ -0,0 +1,151 @@
+import datetime
+import unittest
+from unittest import mock
+from gn2.wqflask.show_trait.export_trait_data import dict_to_sorted_list
+from gn2.wqflask.show_trait.export_trait_data import cmp_samples
+from gn2.wqflask.show_trait.export_trait_data import export_sample_table
+from gn2.wqflask.show_trait.export_trait_data import get_export_metadata
+
+
+class AttributesSetter:
+ def __init__(self, obj):
+ for key, value in obj.items():
+ setattr(self, key, value)
+
+
+class TestExportTraits(unittest.TestCase):
+ """Test methods for exporting traits and metadata"""
+
+ @mock.patch("wqflask.show_trait.export_trait_data.datetime")
+ @mock.patch("wqflask.show_trait.export_trait_data.create_trait")
+ @mock.patch("wqflask.show_trait.export_trait_data.data_set")
+ def test_get_export_metadata(self, data_mock, trait_mock, date_mock):
+ """test for exporting metadata with dataset.type=Publish"""
+ mock_dataset = AttributesSetter({"type": "Publish",
+ "name": "HC_M2_0606_P",
+ "dataset_name": "HC_M2_0606_P"})
+
+ mock_dataset.group = AttributesSetter({"name": "C"})
+ data_mock.create_dataset.return_value = mock_dataset
+
+ trait_data = {
+ "symbol": "Nr3c1",
+ "description_display": "nuclear receptor subfamily 3,group C, member 1 (glucocorticoid receptor); distal 3' UTR",
+ "title": "Trait_1 title",
+
+ "authors": "XL_1",
+ "journal": ""
+
+ }
+
+ date_mock.datetime.now.return_value = datetime.datetime(
+ 2022, 8, 8, 19, 2, 31, 628813)
+ trait_mock.return_value = AttributesSetter(trait_data)
+
+ results = get_export_metadata({
+ "trait_id": "1460303_at",
+ "trait_display_name": "1460303_at",
+ "dataset": "HC_M2_0606_P",
+ "group": "BXD",
+ })
+
+ expected = [["Phenotype ID:", "1460303_at"],
+ ["Phenotype URL: ", "http://genenetwork.org/show_trait?trait_id=1460303_at&dataset=HC_M2_0606_P"],
+ ["Group: ", "C"],
+ ["Phenotype: ",
+ 'nuclear receptor subfamily 3","group C"," member 1 (glucocorticoid receptor); distal 3\' UTR'],
+ ["Authors: ", "XL_1"],
+ ["Title: ", "Trait_1 title"],
+ ["Journal: ", "N/A"],
+ ["Dataset Link: ", "http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=HC_M2_0606_P"],
+ ["Export Date: ", "August 08, 2022"],
+ ["Export Time: ", "19:02 GMT"]]
+
+ self.assertEqual(results, expected)
+
+ def test_dict_to_sortedlist(self):
+ """test for conversion of dict to sorted list"""
+ sample1 = {
+ "other": "exp1",
+ "name": "exp2"
+ }
+ sample2 = {
+ "se": 1,
+ "num_cases": 4,
+ "value": 6,
+ "name": 3
+
+ }
+ rever = {
+ "name": 3,
+ "value": 6,
+ "num_cases": 4,
+ "se": 1
+ }
+ oneItem = {
+ "item1": "one"
+ }
+
+ self.assertEqual(["exp2", "exp1"], dict_to_sorted_list(sample1))
+ self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(sample2))
+ self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(rever))
+ self.assertEqual(["one"], dict_to_sorted_list(oneItem))
+ """test that the func returns the values not the keys"""
+ self.assertFalse(["other", "name"] == dict_to_sorted_list(sample1))
+
+ def test_cmp_samples(self):
+ """test for comparing samples function"""
+ sampleA = [
+ [
+ ("value", "other"),
+ ("name", "test_name")
+ ]
+ ]
+ sampleB = [
+ [
+ ("value", "other"),
+ ("unknown", "test_name")
+ ]
+ ]
+ sampleC = [
+ [("other", "value"),
+ ("name", "value")
+ ],
+ [
+ ("name", "value"),
+ ("value", "name")
+ ],
+ [
+ ("other", "value"),
+ ("name", "value"
+ )],
+ [
+ ("name", "name1"),
+ ("se", "valuex")
+ ],
+ [(
+ "value", "name1"),
+ ("se", "valuex")
+ ],
+ [(
+ "other", "name1"),
+ ("se", "valuex"
+ )
+ ],
+ [(
+ "name", "name_val"),
+ ("num_cases", "num_val")
+ ],
+ [(
+ "other_a", "val_a"),
+ ("other_b", "val"
+ )
+ ]
+ ]
+ results = [cmp_samples(val[0], val[1]) for val in sampleA]
+ resultB = [cmp_samples(val[0], val[1]) for val in sampleB]
+ resultC = [cmp_samples(val[0], val[1]) for val in sampleC]
+
+ self.assertEqual(1, *results)
+ self.assertEqual(-1, *resultB)
+ self.assertEqual([1, -1, 1, -1, -1, 1, -1, -1], resultC)
diff --git a/gn2/tests/unit/wqflask/show_trait/test_get_max_digits.py b/gn2/tests/unit/wqflask/show_trait/test_get_max_digits.py
new file mode 100644
index 00000000..45484f17
--- /dev/null
+++ b/gn2/tests/unit/wqflask/show_trait/test_get_max_digits.py
@@ -0,0 +1,15 @@
+import pytest
+import unittest
+
+from gn2.wqflask.show_trait.show_trait import get_max_digits
+
+@unittest.skip("Too complicated")
+@pytest.mark.parametrize(
+ "trait_vals,expected",
+ (((
+ (0, 1345, 92, 734),
+ (234253, 33, 153, 5352),
+ (3542, 24, 135)),
+ [3, 5, 3]),))
+def test_get_max_digits(trait_vals, expected):
+ assert get_max_digits(trait_vals) == expected
diff --git a/gn2/tests/unit/wqflask/snp_browser/__init__.py b/gn2/tests/unit/wqflask/snp_browser/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/gn2/tests/unit/wqflask/snp_browser/test_snp_browser.py b/gn2/tests/unit/wqflask/snp_browser/test_snp_browser.py
new file mode 100644
index 00000000..c33f46ef
--- /dev/null
+++ b/gn2/tests/unit/wqflask/snp_browser/test_snp_browser.py
@@ -0,0 +1,206 @@
+import unittest
+from unittest import mock
+from gn2.wqflask import app
+from gn2.wqflask.snp_browser.snp_browser import get_gene_id
+from gn2.wqflask.snp_browser.snp_browser import get_gene_id_name_dict
+from gn2.wqflask.snp_browser.snp_browser import check_if_in_gene
+from gn2.wqflask.snp_browser.snp_browser import get_browser_sample_lists
+from gn2.wqflask.snp_browser.snp_browser import get_header_list
+
+
+class TestSnpBrowser(unittest.TestCase):
+ def setUp(self):
+ self.app_context = app.app_context()
+ self.app_context.push()
+
+ def tearDown(self):
+ self.app_context.pop()
+
+ def test_get_header_list(self):
+ empty_columns = {
+ "snp_source": "false",
+ "conservation_score": "true",
+ "gene_name": "false",
+ "transcript": "false",
+ "exon": "false",
+ "domain_2": "true",
+ "function": "false",
+ "function_details": "true",
+ }
+ strains = {"mouse": ["S1", "S2", "S3", "S4", "S5"], "rat": []}
+ expected_results = (
+ [
+ [
+ "Index",
+ "SNP ID",
+ "Chr",
+ "Mb",
+ "Alleles",
+ "ConScore",
+ "Domain 1",
+ "Domain 2",
+ "Details",
+ ],
+ ["S1", "S2", "S3", "S4", "S5"],
+ ],
+ 5,
+ [
+ "index",
+ "snp_name",
+ "chr",
+ "mb_formatted",
+ "alleles",
+ "conservation_score",
+ "domain_1",
+ "domain_2",
+ "function_details",
+ "S1",
+ "S2",
+ "S3",
+ "S4",
+ "S5",
+ ],
+ )
+
+ results_with_snp = get_header_list(
+ variant_type="SNP",
+ strains=strains,
+ species="Mouse",
+ empty_columns=empty_columns,
+ )
+ results_with_indel = get_header_list(
+ variant_type="InDel", strains=strains, species="rat", empty_columns=[]
+ )
+ expected_results_with_indel = (
+ [
+ "Index",
+ "ID",
+ "Type",
+ "InDel Chr",
+ "Mb Start",
+ "Mb End",
+ "Strand",
+ "Size",
+ "Sequence",
+ "Source",
+ ],
+ 0,
+ [
+ "index",
+ "indel_name",
+ "indel_type",
+ "indel_chr",
+ "indel_mb_s",
+ "indel_mb_e",
+ "indel_strand",
+ "indel_size",
+ "indel_sequence",
+ "source_name",
+ ],
+ )
+
+ self.assertEqual(expected_results, results_with_snp)
+ self.assertEqual(expected_results_with_indel, results_with_indel)
+
+ @mock.patch("wqflask.snp_browser.snp_browser.database_connection")
+ def test_get_gene_id(self, mock_db):
+ db_query_value = (
+ "SELECT geneId FROM GeneList WHERE " "SpeciesId = %s AND geneSymbol = %s"
+ )
+ conn = mock.MagicMock()
+ mock_db.return_value.__enter__.return_value = conn
+ with conn.cursor() as cursor:
+ cursor.fetchone.return_value = (
+ ("517d729f-aa13-4413" "-a885-40a3f7ff768a"),
+ )
+
+ results = get_gene_id(
+ species_id="c9c0f59e-1259-4cba-91e6-831ef1a99c83", gene_name="INSR"
+ )
+ cursor.execute.assert_called_once_with(
+ db_query_value, ("c9c0f59e-1259-4cba-91e6-831ef1a99c83", "INSR")
+ )
+ self.assertEqual(results, "517d729f-aa13-4413-a885-40a3f7ff768a")
+
+ @mock.patch("wqflask.snp_browser.snp_browser.database_connection")
+ def test_gene_id_name_dict(self, mock_db):
+ no_gene_names = []
+ conn = mock.MagicMock()
+ mock_db.return_value.__enter__.return_value = conn
+ with conn.cursor() as cursor:
+ cursor.fetchall.side_effect = [
+ [],
+ [
+ ("fsdf43-fseferger-f22", "GH1"),
+ ("1sdf43-fsewferger-f22", "GH2"),
+ ("fwdj43-fstferger-f22", "GH3"),
+ ],
+ ]
+ self.assertEqual(
+ "",
+ get_gene_id_name_dict(
+ species_id="fregb343bui43g4", gene_name_list=no_gene_names
+ ),
+ )
+ gene_name_list = ["GH1", "GH2", "GH3"]
+ no_results = get_gene_id_name_dict(
+ species_id="ret3-32rf32", gene_name_list=gene_name_list
+ )
+ results_found = get_gene_id_name_dict(
+ species_id="ret3-32rf32", gene_name_list=gene_name_list
+ )
+ expected_found = {
+ "GH1": "fsdf43-fseferger-f22",
+ "GH2": "1sdf43-fsewferger-f22",
+ "GH3": "fwdj43-fstferger-f22",
+ }
+ db_query_value = (
+ "SELECT geneId, geneSymbol FROM GeneList WHERE "
+ "SpeciesId = %s AND geneSymbol in (%s, %s, %s)"
+ )
+ cursor.execute.assert_called_with(
+ db_query_value, ("ret3-32rf32", "GH1", "GH2", "GH3")
+ )
+ self.assertEqual(results_found, expected_found)
+ self.assertEqual(no_results, {})
+
+ @mock.patch("wqflask.snp_browser.snp_browser.database_connection")
+ def test_check_if_in_gene(self, mock_db):
+ conn = mock.MagicMock()
+ mock_db.return_value.__enter__.return_value = conn
+ with conn.cursor() as cursor:
+ cursor.fetchone.side_effect = [("fsdf-232sdf-sdf", "GHA"), ""]
+ results_found = check_if_in_gene(
+ species_id="517d729f-aa13-4413-a885-40a3f7ff768a", chr_="CH1", mb=12.09
+ )
+ self.assertEqual(results_found, ["fsdf-232sdf-sdf", "GHA"])
+ db_query_value = (
+ "SELECT geneId, geneSymbol FROM GeneList "
+ "WHERE SpeciesId = %s AND chromosome = %s "
+ "AND (txStart < %s AND txEnd > %s)"
+ )
+ gene_not_found = check_if_in_gene(
+ species_id="517d729f-aa13-4413-a885-40a3f7ff768a", chr_="CH1", mb=12.09
+ )
+ cursor.execute.assert_has_calls(
+ [
+ mock.call(
+ db_query_value,
+ ("517d729f-aa13-4413-a885-40a3f7ff768a", "CH1", 12.09, 12.09),
+ ),
+ mock.call(
+ db_query_value,
+ ("517d729f-aa13-4413-a885-40a3f7ff768a", "CH1", 12.09, 12.09),
+ ),
+ ]
+ )
+ self.assertEqual(gene_not_found, "")
+
+ @mock.patch("wqflask.snp_browser.snp_browser.database_connection")
+ def test_get_browser_sample_lists(self, mock_db):
+ conn = mock.MagicMock()
+ mock_db.return_value.__enter__.return_value = conn
+ with conn.cursor() as cursor:
+ cursor.execute.return_value.fetchall.return_value = []
+ results = get_browser_sample_lists(species_id="12")
+ self.assertEqual(results, {"mouse": [], "rat": []})
diff --git a/gn2/tests/unit/wqflask/test_collect.py b/gn2/tests/unit/wqflask/test_collect.py
new file mode 100644
index 00000000..41d6bf74
--- /dev/null
+++ b/gn2/tests/unit/wqflask/test_collect.py
@@ -0,0 +1,75 @@
+"""Test cases for some methods in collect.py"""
+
+import unittest
+from unittest import mock
+
+from flask import Flask
+from gn2.wqflask.collect import process_traits
+
+app = Flask(__name__)
+
+
+class MockSession:
+ """Helper class for mocking wqflask.collect.g.user_session.logged_in"""
+
+ def __init__(self, is_logged_in=False):
+ self.is_logged_in = is_logged_in
+
+ @property
+ def logged_in(self):
+ return self.is_logged_in
+
+
+class MockFlaskG:
+ """Helper class for mocking wqflask.collect.g.user_session"""
+
+ def __init__(self, is_logged_in=False):
+ self.is_logged_in = is_logged_in
+
+ @property
+ def user_session(self):
+ if self.is_logged_in:
+ return MockSession(is_logged_in=True)
+ return MockSession()
+
+
+class TestCollect(unittest.TestCase):
+
+ def setUp(self):
+ self.app_context = app.app_context()
+ self.app_context.push()
+
+ def tearDown(self):
+ self.app_context.pop()
+
+ @mock.patch("wqflask.collect.g", MockFlaskG())
+ def test_process_traits_with_bytestring(self):
+ """
+ Test that the correct traits are returned when the user is logged
+ out and bytes are used.
+ """
+ self.assertEqual(sorted(process_traits(
+ b'1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,'
+ b'1452447_at:HC_M2_0606_P:eeece8fceb67072debea,'
+ b'1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,'
+ b'1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5')),
+ sorted(['1429252_at:HC_M2_0606_P',
+ '1451401_a_at:HC_M2_0606_P',
+ '1452447_at:HC_M2_0606_P',
+ '1452452_at:HC_M2_0606_P']))
+
+ @mock.patch("wqflask.collect.g", MockFlaskG())
+ def test_process_traits_with_normal_string(self):
+ """
+ Test that the correct traits are returned when the user is logged
+ out and a normal string is used.
+ """
+ self.assertEqual(sorted(process_traits(
+ '1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,'
+ '1452447_at:HC_M2_0606_P:eeece8fceb67072debea,'
+ '1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,'
+ '1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5')),
+ sorted(['1429252_at:HC_M2_0606_P',
+ '1451401_a_at:HC_M2_0606_P',
+ '1452447_at:HC_M2_0606_P',
+ '1452452_at:HC_M2_0606_P']))
diff --git a/gn2/tests/unit/wqflask/test_pbkdf2.py b/gn2/tests/unit/wqflask/test_pbkdf2.py
new file mode 100644
index 00000000..ed4eff4f
--- /dev/null
+++ b/gn2/tests/unit/wqflask/test_pbkdf2.py
@@ -0,0 +1,61 @@
+"""Test cases pbkdf2"""
+
+import unittest
+from gn2.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/gn2/tests/unit/wqflask/test_resource_manager.py b/gn2/tests/unit/wqflask/test_resource_manager.py
new file mode 100644
index 00000000..f4335425
--- /dev/null
+++ b/gn2/tests/unit/wqflask/test_resource_manager.py
@@ -0,0 +1,94 @@
+"""Test cases for wqflask/resource_manager.py"""
+import json
+import unittest
+
+from unittest import mock
+from gn3.authentication import get_user_membership
+from gn3.authentication import get_highest_user_access_role
+from gn3.authentication import DataRole
+from gn3.authentication import AdminRole
+
+
+class TestGetUserMembership(unittest.TestCase):
+ """Test cases for `get_user_membership`"""
+
+ def setUp(self):
+ conn = mock.MagicMock()
+ conn.hgetall.return_value = {
+ '7fa95d07-0e2d-4bc5-b47c-448fdc1260b2': (
+ '{"name": "editors", '
+ '"admins": ["8ad942fe-490d-453e-bd37-56f252e41604", "rand"], '
+ '"members": ["8ad942fe-490d-453e-bd37-56f252e41603", '
+ '"rand"], '
+ '"changed_timestamp": "Oct 06 2021 06:39PM", '
+ '"created_timestamp": "Oct 06 2021 06:39PM"}')}
+ self.conn = conn
+
+ def test_user_is_group_member_only(self):
+ """Test that a user is only a group member"""
+ self.assertEqual(
+ get_user_membership(
+ conn=self.conn,
+ user_id="8ad942fe-490d-453e-bd37-56f252e41603",
+ group_id="7fa95d07-0e2d-4bc5-b47c-448fdc1260b2"),
+ {"member": True,
+ "admin": False})
+
+ def test_user_is_group_admin_only(self):
+ """Test that a user is a group admin only"""
+ self.assertEqual(
+ get_user_membership(
+ conn=self.conn,
+ user_id="8ad942fe-490d-453e-bd37-56f252e41604",
+ group_id="7fa95d07-0e2d-4bc5-b47c-448fdc1260b2"),
+ {"member": False,
+ "admin": True})
+
+ def test_user_is_both_group_member_and_admin(self):
+ """Test that a user is both an admin and member of a group"""
+ self.assertEqual(
+ get_user_membership(
+ conn=self.conn,
+ user_id="rand",
+ group_id="7fa95d07-0e2d-4bc5-b47c-448fdc1260b2"),
+ {"member": True,
+ "admin": True})
+
+
+class TestCheckUserAccessRole(unittest.TestCase):
+ """Test cases for `get_highest_user_access_role`"""
+
+ @mock.patch("wqflask.resource_manager.requests.get")
+ def test_edit_access(self, requests_mock):
+ """Test that the right access roles are set"""
+ response = mock.PropertyMock(return_value=json.dumps(
+ {
+ 'data': ['no-access', 'view', 'edit', ],
+ 'metadata': ['no-access', 'view', 'edit', ],
+ 'admin': ['not-admin', 'edit-access', ],
+ }
+ ))
+ type(requests_mock.return_value).content = response
+ self.assertEqual(get_highest_user_access_role(
+ resource_id="0196d92e1665091f202f",
+ user_id="8ad942fe-490d-453e-bd37"),
+ {"data": DataRole.EDIT,
+ "metadata": DataRole.EDIT,
+ "admin": AdminRole.EDIT_ACCESS})
+
+ @mock.patch("wqflask.resource_manager.requests.get")
+ def test_no_access(self, requests_mock):
+ response = mock.PropertyMock(return_value=json.dumps(
+ {
+ 'data': ['no-access', ],
+ 'metadata': ['no-access', ],
+ 'admin': ['not-admin', ],
+ }
+ ))
+ type(requests_mock.return_value).content = response
+ self.assertEqual(get_highest_user_access_role(
+ resource_id="0196d92e1665091f202f",
+ user_id=""),
+ {"data": DataRole.NO_ACCESS,
+ "metadata": DataRole.NO_ACCESS,
+ "admin": AdminRole.NOT_ADMIN})
diff --git a/gn2/tests/unit/wqflask/test_server_side.py b/gn2/tests/unit/wqflask/test_server_side.py
new file mode 100644
index 00000000..b3e90eb9
--- /dev/null
+++ b/gn2/tests/unit/wqflask/test_server_side.py
@@ -0,0 +1,34 @@
+import unittest
+
+from gn2.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/gn2/tests/unit/wqflask/test_user_login.py b/gn2/tests/unit/wqflask/test_user_login.py
new file mode 100644
index 00000000..84e25d45
--- /dev/null
+++ b/gn2/tests/unit/wqflask/test_user_login.py
@@ -0,0 +1,21 @@
+"""Test cases for some methods in login.py"""
+
+import unittest
+from gn2.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/gn2/tests/unit/wqflask/test_user_session.py b/gn2/tests/unit/wqflask/test_user_session.py
new file mode 100644
index 00000000..944e5b6a
--- /dev/null
+++ b/gn2/tests/unit/wqflask/test_user_session.py
@@ -0,0 +1,15 @@
+"""Test cases for some methods in user_session.py"""
+
+import unittest
+from gn2.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/gn2/tests/unit/wqflask/wgcna/__init__.py b/gn2/tests/unit/wqflask/wgcna/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/gn2/tests/unit/wqflask/wgcna/test_wgcna.py b/gn2/tests/unit/wqflask/wgcna/test_wgcna.py
new file mode 100644
index 00000000..2ed5e08f
--- /dev/null
+++ b/gn2/tests/unit/wqflask/wgcna/test_wgcna.py
@@ -0,0 +1,50 @@
+
+"""module contains for processing gn3 wgcna data"""
+from unittest import TestCase
+
+from gn2.wqflask.wgcna.gn3_wgcna import process_wgcna_data
+
+
+class DataProcessingTests(TestCase):
+ """class contains data processing tests"""
+
+ def test_data_processing(self):
+ """test for parsing data for datatable"""
+ output = {
+ "input": {
+ "sample_names": ["BXD1", "BXD2", "BXD3", "BXD4", "BXD5", "BXD6"],
+
+ },
+ "output": {
+ "ModEigens": {
+ "MEturquoise": [
+ 0.0646677768085351,
+ 0.137200224277058,
+ 0.63451113720732,
+ -0.544002665501479,
+ -0.489487590361863,
+ 0.197111117570427
+ ],
+ "MEgrey": [
+ 0.213,
+ 0.214,
+ 0.3141,
+ -0.545,
+ -0.423,
+ 0.156,
+ ]
+ }}}
+
+ row_data = [['BXD1', 0.065, 0.213],
+ ['BXD2', 0.137, 0.214],
+ ['BXD3', 0.635, 0.314],
+ ['BXD4', -0.544, -0.545],
+ ['BXD5', -0.489, -0.423],
+ ['BXD6', 0.197, 0.156]]
+
+ expected_results = {
+ "col_names": ["sample_names", "MEturquoise", "MEgrey"],
+ "mod_dataset": row_data
+ }
+
+ self.assertEqual(process_wgcna_data(output), expected_results)
--
cgit v1.2.3