merge changes

53 files changed, 0 insertions, 3802 deletions

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