Merge branch 'testing' into feature/integrate-correlation-api

19 files changed, 455 insertions, 302 deletions

diff --git a/wqflask/tests/unit/base/test_data_set.py b/wqflask/tests/unit/base/test_data_set.py
index 96563a16..66ad361d 100644
--- a/wqflask/tests/unit/base/test_data_set.py
+++ b/wqflask/tests/unit/base/test_data_set.py
@@ -31,14 +31,12 @@ class TestDataSetTypes(unittest.TestCase):
     def tearDown(self):
         self.app_context.pop()
 
-    @mock.patch('base.data_set.g')
-    def test_data_set_type(self, db_mock):
+    def test_data_set_type(self):
         """Test that DatasetType returns correctly if the Redis Instance is not empty
         and the name variable exists in the dictionary
 
         """
         with app.app_context():
-            db_mock.get = mock.Mock()
             redis_mock = mock.Mock()
             redis_mock.get.return_value = self.test_dataset
             self.assertEqual(DatasetType(redis_mock)
@@ -89,10 +87,9 @@ class TestDataSetTypes(unittest.TestCase):
                  '"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\" ")
+            db_mock.db.execute.assert_called_once_with(
+                ("SELECT ProbeSetFreeze.Id FROM ProbeSetFreeze "
+                 + "WHERE ProbeSetFreeze.Name = \"Test\" ")
             )
 
     @mock.patch('base.data_set.g')
@@ -148,9 +145,9 @@ class TestDataSetTypes(unittest.TestCase):
                  '"Test": "Publish"}'))
 
             db_mock.db.execute.assert_called_with(
-                ("SELECT PublishFreeze.Name " +
-                 "FROM PublishFreeze, InbredSet " +
-                 "WHERE InbredSet.Name = 'Test' AND "
+                ("SELECT PublishFreeze.Name "
+                 + "FROM PublishFreeze, InbredSet "
+                 + "WHERE InbredSet.Name = 'Test' AND "
                  "PublishFreeze.InbredSetId = InbredSet.Id")
             )
 
diff --git a/wqflask/tests/unit/base/test_species.py b/wqflask/tests/unit/base/test_species.py
new file mode 100644
index 00000000..9b5c023c
--- /dev/null
+++ b/wqflask/tests/unit/base/test_species.py
@@ -0,0 +1,116 @@
+"""Tests wqflask/base/species.py"""
+
+import unittest
+from unittest import mock
+from base.species import TheSpecies
+from base.species import IndChromosome
+from base.species import Chromosomes
+from collections import OrderedDict
+from wqflask import app
+from dataclasses import dataclass
+
+
+@dataclass
+class MockChromosome:
+    OrderId: int
+    Name: str
+    Length: int
+
+
+@dataclass
+class MockGroup:
+    name: str
+
+
+@dataclass
+class MockDataset:
+    group: MockGroup
+
+
+class TestTheSpecies(unittest.TestCase):
+    """Tests for TheSpecies class"""
+    @mock.patch('base.species.Chromosomes')
+    def test_create_species_with_null_species_name(self, mock_chromosome):
+        """Test that TheSpecies is instantiated correctly when the
+species_name is provided."""
+        mock_chromosome.return_value = 1
+        test_species = TheSpecies(dataset="random_dataset", species_name="a")
+        self.assertEqual(test_species.name, "a")
+        self.assertEqual(test_species.chromosomes, 1)
+
+    @mock.patch('base.species.Chromosomes')
+    def test_create_species_with_species_name(self, mock_chromosome):
+        """Test that TheSpecies is instantiated correctly when the
+species_name is not provided."""
+        mock_chromosome.return_value = 1
+        test_species = TheSpecies(dataset="random_dataset")
+        self.assertEqual(test_species.dataset, "random_dataset")
+        self.assertEqual(test_species.chromosomes, 1)
+        mock_chromosome.assert_called_once_with(dataset="random_dataset")
+
+
+class TestIndChromosome(unittest.TestCase):
+    """Tests for IndChromosome class"""
+
+    def test_create_ind_chromosome(self):
+        """Test that IndChromosome is instantiated correctly"""
+        test_ind_chromosome = IndChromosome(name="Test", length=10000000)
+        self.assertEqual(test_ind_chromosome.name, "Test")
+        self.assertEqual(test_ind_chromosome.length, 10000000)
+        self.assertEqual(test_ind_chromosome.mb_length, 10)
+
+
+class TestChromosomes(unittest.TestCase):
+    """Tests for Chromosomes class"""
+    maxDiff = None
+
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    @mock.patch("base.species.g")
+    def test_create_chromosomes_with_no_species(self, mock_db):
+        """Test instantiating a chromosome without a species"""
+        mock_db.db.execute.return_value.fetchall.return_value = [
+            MockChromosome(1, "X", 100),
+            MockChromosome(2, "Y", 1000),
+            MockChromosome(3, "Z", 10000),
+        ]
+        mock_dataset = MockDataset(MockGroup("Random"))
+        test_chromosomes = Chromosomes(dataset=mock_dataset)
+        self.assertEqual(
+            list(test_chromosomes.chromosomes.keys()),
+            [1, 2, 3]
+        )
+        self.assertEqual(test_chromosomes.dataset, mock_dataset)
+        mock_db.db.execute.assert_called_with(
+            "SELECT Chr_Length.Name, Chr_Length.OrderId, Length "
+            "FROM Chr_Length, InbredSet WHERE "
+            "Chr_Length.SpeciesId = InbredSet.SpeciesId AND "
+            "InbredSet.Name = 'Random' ORDER BY OrderId"
+        )
+
+    @mock.patch("base.species.g")
+    def test_create_chromosomes_with_species(self, mock_db):
+        """Test instantiating a chromosome with a species"""
+        mock_db.db.execute.return_value.fetchall.return_value = [
+            MockChromosome(1, "X", 100),
+            MockChromosome(2, "Y", 1000),
+            MockChromosome(3, "Z", 10000),
+        ]
+        mock_dataset = MockDataset(MockGroup("Random"))
+        test_chromosomes = Chromosomes(dataset=mock_dataset,
+                                       species="testSpecies")
+        self.assertEqual(
+            list(test_chromosomes.chromosomes.keys()),
+            [1, 2, 3]
+        )
+        mock_db.db.execute.assert_called_with(
+            "SELECT Chr_Length.Name, Chr_Length.OrderId, Length "
+            "FROM Chr_Length, Species WHERE "
+            "Chr_Length.SpeciesId = Species.SpeciesId AND "
+            "Species.Name = 'Testspecies' ORDER BY OrderId"
+        )
diff --git a/wqflask/tests/unit/base/test_webqtl_case_data.py b/wqflask/tests/unit/base/test_webqtl_case_data.py
index 8e8ba482..e1555cb4 100644
--- a/wqflask/tests/unit/base/test_webqtl_case_data.py
+++ b/wqflask/tests/unit/base/test_webqtl_case_data.py
@@ -4,15 +4,16 @@ 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")
+                                value=0,
+                                variance=0.0,
+                                num_cases=10,
+                                name2="Test2")
 
     def test_webqtl_case_data_repr(self):
         self.assertEqual(
diff --git a/wqflask/tests/unit/utility/test_authentication_tools.py b/wqflask/tests/unit/utility/test_authentication_tools.py
index 42dcae88..024ab43f 100644
--- a/wqflask/tests/unit/utility/test_authentication_tools.py
+++ b/wqflask/tests/unit/utility/test_authentication_tools.py
@@ -5,6 +5,7 @@ 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
diff --git a/wqflask/tests/unit/utility/test_chunks.py b/wqflask/tests/unit/utility/test_chunks.py
index 8d90a1ec..1d349193 100644
--- a/wqflask/tests/unit/utility/test_chunks.py
+++ b/wqflask/tests/unit/utility/test_chunks.py
@@ -7,6 +7,7 @@ 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),
diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
index d0264b87..1089a36f 100644
--- a/wqflask/tests/unit/wqflask/api/test_correlation.py
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -105,10 +105,10 @@ class TestCorrelations(unittest.TestCase):
         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})}
+        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)
@@ -127,9 +127,9 @@ class TestCorrelations(unittest.TestCase):
         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)
+            self.assertAlmostEqual(val, results_pearsonr[i], 4)
         for i, val in enumerate(expected_spearmanr):
-            self.assertAlmostEqual(val, results_spearmanr[i],4)
+            self.assertAlmostEqual(val, results_spearmanr[i], 4)
         self.assertEqual(results_num_overlap, None)
 
     @mock.patch("wqflask.api.correlation.do_literature_correlation_for_all_traits")
diff --git a/wqflask/tests/unit/wqflask/api/test_gen_menu.py b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
index 57eb1650..743b3bde 100644
--- a/wqflask/tests/unit/wqflask/api/test_gen_menu.py
+++ b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
@@ -2,7 +2,6 @@
 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
@@ -18,8 +17,6 @@ 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',
@@ -70,212 +67,239 @@ class TestGenMenu(unittest.TestCase):
             }
         }
 
-    def tearDown(self):
-        self.app_context.pop()
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_get_species(self, db_mock):
+    def test_get_species(self):
         """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)
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            cursor.fetchall.return_value = (
+                ('human', 'Human'),
+                ('mouse', 'Mouse'))
+            self.assertEqual(get_species(db_mock),
+                             [['human', 'Human'], ['mouse', 'Mouse']])
+            cursor.execute.assert_called_once_with(
+                "SELECT Name, MenuName FROM Species ORDER BY OrderId"
             )
 
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_phenotypes_exist_called_with_correct_query(self, db_mock):
+    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.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):
+        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"""
-        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):
+        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.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"))
+        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))
 
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_genotypes_exist_with_truthy_value(self, db_mock):
+    def test_genotypes_exist_with_truthy_value(self):
         """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"))
+        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))
 
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_phenotypes(self, db_mock):
+    def test_build_datasets_with_type_phenotypes(self):
         """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):
+        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.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):
+        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.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):
+        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.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")
+        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')
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_types(self, db_mock, datasets_mock):
+    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"]
         ]
-        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"
-        )
+        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')
@@ -297,7 +321,9 @@ class TestGenMenu(unittest.TestCase):
         build_types_mock.return_value = [
             ['M', 'M', 'Molecular Trait Datasets']
         ]
-        self.assertEqual(get_types(self.test_group), expected_result)
+        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')
@@ -315,10 +341,8 @@ class TestGenMenu(unittest.TestCase):
         genotypes_exist_mock.return_value = False
 
         build_types_mock.return_value = []
-        self.assertEqual(get_types(self.test_group), {
-            'mouse': {},
-            'human': {}
-        })
+        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')
@@ -345,7 +369,7 @@ class TestGenMenu(unittest.TestCase):
             'human': {
                 'HLC': [['M', 'M', 'Molecular Trait Datasets']],
                 'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
-        self.assertEqual(get_types(self.test_group),
+        self.assertEqual(get_types(self.test_group, mock.MagicMock()),
                          expected_result)
 
     @mock.patch('wqflask.api.gen_menu.build_datasets')
@@ -367,7 +391,7 @@ class TestGenMenu(unittest.TestCase):
                       'BXD': {'Genotypes': 'Test',
                               'M': 'Test',
                               'Phenotypes': 'Test'}}}
-        self.assertEqual(get_datasets(self.test_type),
+        self.assertEqual(get_datasets(self.test_type, mock.MagicMock()),
                          expected_result)
 
     @mock.patch('wqflask.api.gen_menu.build_datasets')
@@ -381,7 +405,7 @@ class TestGenMenu(unittest.TestCase):
                 'H_T1': {}},
             'human': {'HLC': {},
                       'BXD': {}}}
-        self.assertEqual(get_datasets(self.test_type),
+        self.assertEqual(get_datasets(self.test_type, mock.MagicMock()),
                          expected_result)
 
     @mock.patch('wqflask.api.gen_menu.get_datasets')
@@ -411,4 +435,4 @@ class TestGenMenu(unittest.TestCase):
             'groups': ['groupA', 'groupB', 'groupC', 'groupD'],
             'species': ['speciesA', 'speciesB', 'speciesC', 'speciesD']}
 
-        self.assertEqual(gen_dropdown_json(), expected_result)
+        self.assertEqual(gen_dropdown_json(mock.MagicMock()), expected_result)
diff --git a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
index 44d2e0fc..2bbeab1f 100644
--- a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
+++ b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
@@ -5,7 +5,7 @@ from wqflask.correlation.correlation_functions import cal_zero_order_corr_for_ti
 
 
 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"""
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
index 8ae0f09f..f4869c45 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
@@ -9,6 +9,7 @@ from wqflask.marker_regression.display_mapping_results import (
 
 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,
@@ -17,6 +18,7 @@ class TestDisplayMappingResults(unittest.TestCase):
 
 class TestHtmlGenWrapper(unittest.TestCase):
     """Test Wrapper around HTMLGen"""
+
     def test_create_image(self):
         """Test HT.Image method"""
         self.assertEqual(
@@ -37,7 +39,8 @@ class TestHtmlGenWrapper(unittest.TestCase):
             cgi="/testing/",
             enctype='multipart/form-data',
             name="formName",
-            submit=HtmlGenWrapper.create_input_tag(type_='hidden', name='Default_Name')
+            submit=HtmlGenWrapper.create_input_tag(
+                type_='hidden', name='Default_Name')
         )
         test_image = HtmlGenWrapper.create_image_tag(
             src="test.png",
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
index fe2569b8..4003d68f 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -47,11 +47,11 @@ class TestGemmaMapping(unittest.TestCase):
     @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):
+    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={}
+        this_chromosomes = {}
         for i in range(1, 5):
-            this_chromosomes[f'CH{i}']=(AttributeSetter({"name": f"CH{i}"}))
+            this_chromosomes[f'CH{i}'] = (AttributeSetter({"name": f"CH{i}"}))
         chromosomes = AttributeSetter({"chromosomes": this_chromosomes})
 
         dataset_group = MockGroup(
@@ -68,9 +68,10 @@ class TestGemmaMapping(unittest.TestCase):
         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)
+        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_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)
@@ -102,7 +103,8 @@ class TestGemmaMapping(unittest.TestCase):
         create_trait_side_effect = []
 
         for i in range(4):
-            create_dataset_side_effect.append(AttributeSetter({"name": f'name_{i}'}))
+            create_dataset_side_effect.append(
+                AttributeSetter({"name": f'name_{i}'}))
             create_trait_side_effect.append(
                 AttributeSetter({"data": [f'data_{i}']}))
 
@@ -144,7 +146,7 @@ class TestGemmaMapping(unittest.TestCase):
             "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
+        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"""
@@ -159,11 +161,14 @@ X\tM5\t12\tQ\tE\tMMB\tR\t21.1\tW\t0.65\t0.6"""
             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}]
+            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)
 
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
index 5eec93f1..fd21a825 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
@@ -12,9 +12,10 @@ class AttributeSetter:
     def __init__(self, obj):
         for key, val in obj.items():
             setattr(self, key, val)
-class TestPlinkMapping(unittest.TestCase):
 
 
+class TestPlinkMapping(unittest.TestCase):
+
     def test_build_line_list(self):
         """test for building line list"""
         line_1 = "this is line one test"
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
index b47f877a..8b4337ec 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -1,21 +1,24 @@
 import unittest
-from unittest import  mock
-from wqflask.marker_regression.qtlreaper_mapping import  gen_pheno_txt_file
+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
 
-#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)
+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
index c585f1df..91d2c587 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -5,44 +5,38 @@ 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)
-
-
-		
-		
-
 
+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
index a29d8cfb..78cd3be9 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -187,7 +187,8 @@ class TestRunMapping(unittest.TestCase):
                     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('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'),
diff --git a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
index ce3e7b83..89442c47 100644
--- a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
+++ b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
@@ -21,11 +21,11 @@ class TestSnpBrowser(unittest.TestCase):
                          "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'])
+                              '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)
@@ -33,9 +33,9 @@ class TestSnpBrowser(unittest.TestCase):
             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'])
+             '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)
diff --git a/wqflask/tests/unit/wqflask/test_collect.py b/wqflask/tests/unit/wqflask/test_collect.py
index 9a36132d..2a914fb2 100644
--- a/wqflask/tests/unit/wqflask/test_collect.py
+++ b/wqflask/tests/unit/wqflask/test_collect.py
@@ -11,6 +11,7 @@ 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
 
@@ -21,6 +22,7 @@ class MockSession:
 
 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
 
diff --git a/wqflask/tests/unit/wqflask/test_server_side.py b/wqflask/tests/unit/wqflask/test_server_side.py
index 4f91d8ca..be7ca2df 100644
--- a/wqflask/tests/unit/wqflask/test_server_side.py
+++ b/wqflask/tests/unit/wqflask/test_server_side.py
@@ -17,15 +17,18 @@ class TestServerSideTableTests(unittest.TestCase):
     def test_get_page(self):
         rows_count = 3
         table_rows = [
-            {'first': 'd', 'second': 4, 'third': 'zz'}, 
-            {'first': 'b', 'second': 2, 'third': 'aa'}, 
+            {'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'}
+        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()
+        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'}])
+        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/wqflask/show_trait/testSampleList.py b/wqflask/tests/wqflask/show_trait/testSampleList.py
index 34c51e3e..305586ce 100644
--- a/wqflask/tests/wqflask/show_trait/testSampleList.py
+++ b/wqflask/tests/wqflask/show_trait/testSampleList.py
@@ -10,7 +10,8 @@ class TestSampleList(unittest.TestCase):
 
         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)
+        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"])
+        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
index 8c866874..63df2ba5 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -72,7 +72,8 @@ class TestTraits(unittest.TestCase):
         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")
+        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")
 
@@ -242,7 +243,6 @@ class TestTraits(unittest.TestCase):
         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"""