From b55792f2daf648affe52d78c7f3a480f6550dfc8 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 29 Jul 2020 22:09:21 +0300
Subject: Add initial gen_menu test

* wqflask/tests/api/__init__.py: Add it
* wqflask/tests/api/test_gen_menu.py: Add test for get_species
---
 wqflask/tests/api/__init__.py      |  0
 wqflask/tests/api/test_gen_menu.py | 19 +++++++++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 wqflask/tests/api/__init__.py
 create mode 100644 wqflask/tests/api/test_gen_menu.py

(limited to 'wqflask')

diff --git a/wqflask/tests/api/__init__.py b/wqflask/tests/api/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
new file mode 100644
index 00000000..81908129
--- /dev/null
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -0,0 +1,19 @@
+"""Test cases for wqflask.api.gen_menu"""
+import unittest
+import mock
+
+from wqflask.api.gen_menu import get_species
+
+class TestGenMenu(unittest.TestCase):
+    """Tests for the gen_menu module"""
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_get_species(self, db_mock):
+        """Test that assertion is raised when dataset and dataset_name are defined"""
+        db_mock.db.execute.return_value.fetchall.return_value = (('human', 'Human'),
+                                                                 ('mouse', 'Mouse'))
+        self.assertEqual(get_species(),
+                         [['human', 'Human'], ['mouse', 'Mouse']])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT Name, MenuName FROM Species ORDER BY OrderId"
+        )
-- 
cgit v1.2.3


From 3425e7a5dbf5a6983424659c05c258e7a132edf3 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 29 Jul 2020 22:19:13 +0300
Subject: Add test for "get_groups"

* wqflask/tests/api/test_gen_menu.py: test that "get_groups" uses the correct
sql query and returns the correct group data structure.
---
 wqflask/tests/api/test_gen_menu.py | 45 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

(limited to 'wqflask')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index 81908129..a2a93da7 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -3,10 +3,28 @@ import unittest
 import mock
 
 from wqflask.api.gen_menu import get_species
+from wqflask.api.gen_menu import get_groups
+
 
 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']
+            ]
+        }
+
     @mock.patch('wqflask.api.gen_menu.g')
     def test_get_species(self, db_mock):
         """Test that assertion is raised when dataset and dataset_name are defined"""
@@ -17,3 +35,30 @@ class TestGenMenu(unittest.TestCase):
         db_mock.db.execute.assert_called_once_with(
             "SELECT Name, MenuName FROM Species ORDER BY OrderId"
         )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_get_groups(self, db_mock):
+        """Test that species groups are grouped correctly"""
+        db_mock.db.execute.return_value.fetchall.side_effect = [
+            # Mouse
+            (('BXD', 'BXD', None),
+             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)', 'Test')),
+            # Human
+            (('H_T1', "H_T", "DescriptionA"),
+             ('H_T2', "H_T'", None))
+        ]
+
+        self.assertEqual(get_groups([["human", "Human"], ["mouse", "Mouse"]]),
+                         self.test_group)
+
+        for name in ["mouse", "human"]:
+            db_mock.db.execute.assert_any_call(
+                ("SELECT InbredSet.Name, InbredSet.FullName, " +
+                 "IFNULL(InbredSet.Family, 'None') " +
+                 "FROM InbredSet, Species WHERE Species.Name " +
+                 "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by " +
+                 "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, " +
+                 "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, " +
+                 "InbredSet.FullName) ASC, InbredSet.FullName ASC, " +
+                 "InbredSet.MenuOrderId ASC").format(name)
+            )
-- 
cgit v1.2.3


From d50f72869b8d0a7078f0481aad2b04346cd56e3f Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 29 Jul 2020 22:28:38 +0300
Subject: Add tests for "phenotypes_exist" and "genotypes_exist"

* wqflask/tests/api/test_gen_menu.py: Add new tests
---
 wqflask/tests/api/test_gen_menu.py | 49 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

(limited to 'wqflask')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index a2a93da7..be66a4c6 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -4,6 +4,8 @@ import mock
 
 from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
+from wqflask.api.gen_menu import phenotypes_exist
+from wqflask.api.gen_menu import genotypes_exist
 
 
 class TestGenMenu(unittest.TestCase):
@@ -62,3 +64,50 @@ class TestGenMenu(unittest.TestCase):
                  "InbredSet.FullName) ASC, InbredSet.FullName ASC, " +
                  "InbredSet.MenuOrderId ASC").format(name)
             )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_called_with_correct_query(self, db_mock):
+        """Test that phenotypes_exist is called with the correct query"""
+        db_mock.db.execute.return_value.fetchone.return_value = None
+        phenotypes_exist("test")
+        db_mock.db.execute.assert_called_with(
+            "SELECT Name FROM PublishFreeze WHERE PublishFreeze.Name = 'testPublish'"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_with_falsy_values(self, db_mock):
+        """Test that phenotype check returns correctly when given a None value"""
+        for x in [None, False, (), [], ""]:
+            db_mock.db.execute.return_value.fetchone.return_value = x
+            self.assertFalse(phenotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_with_truthy_value(self, db_mock):
+        """Test that phenotype check returns correctly when given Truthy """
+        for x in ["x", ("result"), ["result"], [1]]:
+            db_mock.db.execute.return_value.fetchone.return_value = (x)
+            self.assertTrue(phenotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_called_with_correct_query(self, db_mock):
+        """Test that genotypes_exist is called with the correct query"""
+        db_mock.db.execute.return_value.fetchone.return_value = None
+        genotypes_exist("test")
+        db_mock.db.execute.assert_called_with(
+            "SELECT Name FROM GenoFreeze WHERE GenoFreeze.Name = 'testGeno'"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_with_falsy_values(self, db_mock):
+        """Test that genotype check returns correctly when given a None value"""
+        for x in [None, False, (), [], ""]:
+            db_mock.db.execute.return_value.fetchone.return_value = x
+            self.assertFalse(genotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_with_truthy_value(self, db_mock):
+        """Test that genotype check returns correctly when given Truthy """
+        for x in ["x", ("result"), ["result"], [1]]:
+            db_mock.db.execute.return_value.fetchone.return_value = (x)
+            self.assertTrue(phenotypes_exist("test"))
+
-- 
cgit v1.2.3


From 36c85b7f82c584b869182f097cd0b8577dfef0d4 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 29 Jul 2020 22:12:53 +0300
Subject: Reformat sql queries to be one line

* wqflask/wqflask/api/gen_menu.py (get_species, get_groups, phenotypes_exist)
(genotypes_exist)[sql]: Strip white spaces and newlines from query and make the
sql query one line.
---
 wqflask/wqflask/api/gen_menu.py | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

(limited to 'wqflask')

diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index cfce0c8e..69a927cd 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -31,9 +31,7 @@ def gen_dropdown_json():
 
 def get_species():
     """Build species list"""
-    results = g.db.execute("""SELECT Name, MenuName
-                              FROM Species
-                              ORDER BY OrderId""").fetchall()
+    results = g.db.execute("SELECT Name, MenuName FROM Species ORDER BY OrderId").fetchall()
 
     species = []
     for result in results:
@@ -47,12 +45,12 @@ def get_groups(species):
     for species_name, _species_full_name in species:
         groups[species_name] = []
 
-        results = g.db.execute("""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(species_name)).fetchall()
+        results = g.db.execute(
+            ("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(species_name)).fetchall()
 
         for result in results:
             family_name = "Family:" + str(result[2])
@@ -92,9 +90,9 @@ def get_types(groups):
     return types
 
 def phenotypes_exist(group_name):
-    results = g.db.execute("""SELECT Name
-                              FROM PublishFreeze
-                              WHERE PublishFreeze.Name = '{}'""".format(group_name+"Publish")).fetchone()
+    results = g.db.execute(
+        ("SELECT Name FROM PublishFreeze " +
+         "WHERE PublishFreeze.Name = '{}'").format(group_name+"Publish")).fetchone()
 
     if results != None:
         return True
@@ -102,9 +100,9 @@ def phenotypes_exist(group_name):
         return False
 
 def genotypes_exist(group_name):
-    results = g.db.execute("""SELECT Name
-                              FROM GenoFreeze
-                              WHERE GenoFreeze.Name = '{}'""".format(group_name+"Geno")).fetchone()
+    results = g.db.execute(
+        ("SELECT Name FROM GenoFreeze " +
+         "WHERE GenoFreeze.Name = '{}'").format(group_name+"Geno")).fetchone()
 
     if results != None:
         return True
-- 
cgit v1.2.3


From 81dc6616d3cb52be43e8a9c8341f97ab131fc8e7 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 29 Jul 2020 23:14:51 +0300
Subject: Update how boolean is returned

* wqflask/wqflask/api/gen_menu.py (phenotypes_exist, genotypes_exist): Convert
sql result to boolean instead of only checking for "None".
---
 wqflask/wqflask/api/gen_menu.py | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

(limited to 'wqflask')

diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index 69a927cd..0adf3cee 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -93,21 +93,15 @@ def phenotypes_exist(group_name):
     results = g.db.execute(
         ("SELECT Name FROM PublishFreeze " +
          "WHERE PublishFreeze.Name = '{}'").format(group_name+"Publish")).fetchone()
+    return bool(results)
 
-    if results != None:
-        return True
-    else:
-        return False
 
 def genotypes_exist(group_name):
     results = g.db.execute(
         ("SELECT Name FROM GenoFreeze " +
          "WHERE GenoFreeze.Name = '{}'").format(group_name+"Geno")).fetchone()
+    return bool(results)
 
-    if results != None:
-        return True
-    else:
-        return False
 
 def build_types(species, group):
     """Fetches tissues
-- 
cgit v1.2.3


From 99fae55d98e7042e0caf29c34fb77ee17efaafa2 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 30 Jul 2020 16:13:39 +0300
Subject: Add tests for "build_datasets"

* wqflask/tests/api/test_gen_menu.py: Add new tests for "build_datasets"
function
---
 wqflask/tests/api/test_gen_menu.py | 66 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

(limited to 'wqflask')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index be66a4c6..ec380b6f 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -6,6 +6,7 @@ from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
 from wqflask.api.gen_menu import phenotypes_exist
 from wqflask.api.gen_menu import genotypes_exist
+from wqflask.api.gen_menu import build_datasets
 
 
 class TestGenMenu(unittest.TestCase):
@@ -111,3 +112,68 @@ class TestGenMenu(unittest.TestCase):
             db_mock.db.execute.return_value.fetchone.return_value = (x)
             self.assertTrue(phenotypes_exist("test"))
 
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_phenotypes(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            (602, "BXDPublish", "BXD Published Phenotypes"),
+        )
+        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
+                         [['602', "BXDPublish", "BXD Published Phenotypes"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " +
+            "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " +
+            "InbredSet WHERE InbredSet.Name = 'BXD' AND " +
+            "PublishFreeze.InbredSetId = InbredSet.Id AND " +
+            "InfoFiles.InfoPageName = PublishFreeze.Name " +
+            "ORDER BY PublishFreeze.CreateTime ASC"
+        )
+        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
+                         [['602', "BXDPublish", "Mouse Phenome Database"]])
+
+        db_mock.db.execute.return_value.fetchall.return_value = ()
+        db_mock.db.execute.return_value.fetchone.return_value = (
+            "BXDPublish", "Mouse Phenome Database"
+        )
+        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
+                         [["None", "BXDPublish", "Mouse Phenome Database"]])
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_genotypes(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type"""
+        db_mock.db.execute.return_value.fetchone.return_value = (
+            635, "HLCPublish", "HLC Published Genotypes"
+        )
+
+        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
+                         [["635", "HLCGeno", "HLC Genotypes"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, GenoFreeze, InbredSet " +
+            "WHERE InbredSet.Name = 'HLC' AND GenoFreeze.InbredSetId = InbredSet.Id AND " +
+            "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
+            "ORDER BY GenoFreeze.CreateTime DESC"
+        )
+        db_mock.db.execute.return_value.fetchone.return_value = ()
+        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
+                         [["None", "HLCGeno", "HLC Genotypes"]])
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_mrna(self, db_mock):
+        """Test that correct dataset is returned for a mRNA expression/ Probeset"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            (112, "HC_M2_0606_P",
+             "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
+        self.assertEqual(build_datasets("Mouse", "HLC", "mRNA"), [[
+            "112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"
+        ]])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " +
+            "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " +
+            "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
+            "Species.Name = 'Mouse' AND Species.Id = " +
+            "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND " +
+            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and " +
+            "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
+            "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
+            "ORDER BY ProbeSetFreeze.CreateTime DESC")
-- 
cgit v1.2.3


From 43bfbc5c17806fd84dd4582d5f40d56ec0ab23d2 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 30 Jul 2020 16:16:53 +0300
Subject: Reformat sql queries to be one line

* wqflask/wqflask/api/gen_menu.py (build_datasets, build_types): Strip white
spaces and newlines from query and make the sql query one line.
---
 wqflask/wqflask/api/gen_menu.py | 77 +++++++++++++++++++++--------------------
 1 file changed, 40 insertions(+), 37 deletions(-)

(limited to 'wqflask')

diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index 0adf3cee..1a121c33 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -111,15 +111,14 @@ def build_types(species, group):
 
     """
 
-    query = """SELECT DISTINCT Tissue.Name
-               FROM ProbeFreeze, ProbeSetFreeze, InbredSet, Tissue, Species
-               WHERE Species.Name = '{0}' AND
-                     Species.Id = InbredSet.SpeciesId AND
-                     InbredSet.Name = '{1}' AND
-                     ProbeFreeze.TissueId = Tissue.Id AND
-                     ProbeFreeze.InbredSetId = InbredSet.Id AND
-                     ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id
-               ORDER BY Tissue.Name""".format(species, group)
+    query = ("SELECT DISTINCT Tissue.Name " +
+             "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " +
+             "Tissue, Species WHERE Species.Name = '{0}' " +
+             "AND Species.Id = InbredSet.SpeciesId AND " +
+             "InbredSet.Name = '{1}' AND ProbeFreeze.TissueId = " +
+             "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id " +
+             "AND ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
+             "ORDER BY Tissue.Name").format(species, group)
 
     results = []
     for result in g.db.execute(query).fetchall():
@@ -150,14 +149,14 @@ def build_datasets(species, group, type_name):
     dataset_text = dataset_value = None
     datasets = []
     if type_name == "Phenotypes":
-        results = g.db.execute("""SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, PublishFreeze.FullName
-                                  FROM InfoFiles, PublishFreeze, InbredSet
-                                  WHERE InbredSet.Name = '{}' AND
-                                        PublishFreeze.InbredSetId = InbredSet.Id AND
-                                        InfoFiles.InfoPageName = PublishFreeze.Name
-                                  ORDER BY PublishFreeze.CreateTime ASC""".format(group)).fetchall()
-
         if len(results) > 0:
+        results = g.db.execute(
+            ("SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " +
+             "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " +
+             "InbredSet WHERE InbredSet.Name = '{}' AND " +
+             "PublishFreeze.InbredSetId = InbredSet.Id AND " +
+             "InfoFiles.InfoPageName = PublishFreeze.Name " +
+             "ORDER BY PublishFreeze.CreateTime ASC").format(group)).fetchall()
             for result in results:
                 dataset_id = str(result[0])
                 dataset_value = str(result[1])
@@ -168,11 +167,13 @@ def build_datasets(species, group, type_name):
                     dataset_text = str(result[2])
                 datasets.append([dataset_id, dataset_value, dataset_text])
         else:
-            result = g.db.execute("""SELECT PublishFreeze.Name, PublishFreeze.FullName
-                                      FROM PublishFreeze, InbredSet
-                                      WHERE InbredSet.Name = '{}' AND
-                                          PublishFreeze.InbredSetId = InbredSet.Id
-                                      ORDER BY PublishFreeze.CreateTime ASC""".format(group)).fetchone()
+            result = g.db.execute(
+                ("SELECT PublishFreeze.Name, PublishFreeze.FullName "
+                 "FROM PublishFreeze, InbredSet "
+                 "WHERE InbredSet.Name = '{}' AND "
+                 "PublishFreeze.InbredSetId = InbredSet.Id "
+                 "ORDER BY PublishFreeze.CreateTime ASC")
+                .format(group)).fetchone()
 
             dataset_id = "None"
             dataset_value = str(result[0])
@@ -180,14 +181,14 @@ def build_datasets(species, group, type_name):
             datasets.append([dataset_id, dataset_value, dataset_text])
 
     elif type_name == "Genotypes":
-        results = g.db.execute("""SELECT InfoFiles.GN_AccesionId
-                                  FROM InfoFiles, GenoFreeze, InbredSet
-                                  WHERE InbredSet.Name = '{}' AND
-                                        GenoFreeze.InbredSetId = InbredSet.Id AND
-                                        InfoFiles.InfoPageName = GenoFreeze.ShortName
-                                  ORDER BY GenoFreeze.CreateTime DESC""".format(group)).fetchone()
-
-        if results != None:
+        results = g.db.execute(
+            ("SELECT InfoFiles.GN_AccesionId " +
+             "FROM InfoFiles, GenoFreeze, InbredSet " +
+             "WHERE InbredSet.Name = '{}' AND " +
+             "GenoFreeze.InbredSetId = InbredSet.Id AND " +
+             "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
+             "ORDER BY GenoFreeze.CreateTime DESC").format(group)).fetchone()
+
             dataset_id = str(results[0])
         else:
             dataset_id = "None"
@@ -196,14 +197,16 @@ def build_datasets(species, group, type_name):
         datasets.append([dataset_id, dataset_value, dataset_text])
 
     else: # for mRNA expression/ProbeSet
-        results = g.db.execute("""SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, ProbeSetFreeze.FullName
-                                  FROM ProbeSetFreeze, ProbeFreeze, InbredSet, Tissue, Species
-                                  WHERE Species.Name = '{0}' AND
-                                        Species.Id = InbredSet.SpeciesId AND
-                                        InbredSet.Name = '{1}' AND
-                                        ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and Tissue.Name = '{2}' AND
-                                        ProbeFreeze.TissueId = Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id
-                                  ORDER BY ProbeSetFreeze.CreateTime DESC""".format(species, group, type_name)).fetchall()
+        results = g.db.execute(
+            ("SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " +
+             "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " +
+             "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
+             "Species.Name = '{0}' AND Species.Id = " +
+             "InbredSet.SpeciesId AND InbredSet.Name = '{1}' " +
+             "AND ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
+             "and Tissue.Name = '{2}' AND ProbeFreeze.TissueId = " +
+             "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
+             "ORDER BY ProbeSetFreeze.CreateTime DESC").format(species, group, type_name)).fetchall()
 
         datasets = []
         for dataset_info in results:
-- 
cgit v1.2.3


From 7f4b4b19c049a20c3040af22e104ac1d5fbff160 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 30 Jul 2020 16:20:01 +0300
Subject: Clean up "if ... else" conditional

* wqflask/wqflask/api/gen_menu.py (build_datasets): Make conditionals more
Pythonic
---
 wqflask/wqflask/api/gen_menu.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'wqflask')

diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index 1a121c33..d265a8ee 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -149,7 +149,6 @@ def build_datasets(species, group, type_name):
     dataset_text = dataset_value = None
     datasets = []
     if type_name == "Phenotypes":
-        if len(results) > 0:
         results = g.db.execute(
             ("SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " +
              "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " +
@@ -157,14 +156,14 @@ def build_datasets(species, group, type_name):
              "PublishFreeze.InbredSetId = InbredSet.Id AND " +
              "InfoFiles.InfoPageName = PublishFreeze.Name " +
              "ORDER BY PublishFreeze.CreateTime ASC").format(group)).fetchall()
+        if bool(results):
             for result in results:
                 dataset_id = str(result[0])
                 dataset_value = str(result[1])
+                dataset_text = str(result[2])
                 if group == 'MDP':
                     dataset_text = "Mouse Phenome Database"
-                else:
-                    #dataset_text = "%s Phenotypes" % group
-                    dataset_text = str(result[2])
+
                 datasets.append([dataset_id, dataset_value, dataset_text])
         else:
             result = g.db.execute(
@@ -189,9 +188,10 @@ def build_datasets(species, group, type_name):
              "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
              "ORDER BY GenoFreeze.CreateTime DESC").format(group)).fetchone()
 
+        dataset_id = "None"
+        if bool(results):
             dataset_id = str(results[0])
-        else:
-            dataset_id = "None"
+
         dataset_value = "%sGeno" % group
         dataset_text = "%s Genotypes" % group
         datasets.append([dataset_id, dataset_value, dataset_text])
@@ -215,4 +215,4 @@ def build_datasets(species, group, type_name):
                 this_dataset_info.append(str(info))
             datasets.append(this_dataset_info)
 
-    return datasets
\ No newline at end of file
+    return datasets
-- 
cgit v1.2.3


From 61634e932f8e03f5f53a94a56ff23f50dba891d2 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 11:24:40 +0300
Subject: Add test for "build_types"

* wqflask/tests/api/test_gen_menu.py: New test
---
 wqflask/tests/api/test_gen_menu.py | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

(limited to 'wqflask')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index ec380b6f..24899765 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -7,6 +7,7 @@ from wqflask.api.gen_menu import get_groups
 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):
@@ -177,3 +178,29 @@ class TestGenMenu(unittest.TestCase):
             "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
             "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
             "ORDER BY ProbeSetFreeze.CreateTime DESC")
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_types(self, db_mock, datasets_mock):
+        """Test that correct tissue metadata is returned"""
+        datasets_mock.return_value = [
+            ["112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"]
+        ]
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
+        )
+        self.assertEqual(build_types('mouse', 'random group'),
+                         [['M', 'M', 'Molecular Trait Datasets'],
+                          ['H', 'H', 'Molecular Trait Datasets'],
+                          ['R', 'R', 'Molecular Trait Datasets']])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT DISTINCT Tissue.Name " +
+            "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " +
+            "Tissue, Species WHERE Species.Name = 'mouse' " +
+            "AND Species.Id = InbredSet.SpeciesId AND " +
+            "InbredSet.Name = 'random group' AND " +
+            "ProbeFreeze.TissueId = Tissue.Id AND " +
+            "ProbeFreeze.InbredSetId = InbredSet.Id AND " +
+            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
+            "ORDER BY Tissue.Name"
+        )
-- 
cgit v1.2.3


From bde13316e67bb56eb4a00b365ebb343ab6d00274 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 13:10:31 +0300
Subject: Add tests for "get_types"

* wqflask/tests/api/test_gen_menu.py: Add new tests
---
 wqflask/tests/api/test_gen_menu.py | 105 +++++++++++++++++++++++++++++++++++++
 1 file changed, 105 insertions(+)

(limited to 'wqflask')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index 24899765..0379e297 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -4,6 +4,7 @@ import mock
 
 from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
+from wqflask.api.gen_menu import get_types
 from wqflask.api.gen_menu import phenotypes_exist
 from wqflask.api.gen_menu import genotypes_exist
 from wqflask.api.gen_menu import build_datasets
@@ -204,3 +205,107 @@ class TestGenMenu(unittest.TestCase):
             "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 = {
+            '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']]
+            }
+        }
+
+        build_types_mock.return_value = [
+            ['M', 'M', 'Molecular Trait Datasets']
+        ]
+        self.assertEqual(get_types(self.test_group), expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_buildtype_and_non_existent_genotype_and_phenotypes(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes_exist and
+        genotypes_exist are false but build_type is falsy
+
+        """
+        phenotypes_exist_mock.return_value = False
+        genotypes_exist_mock.return_value = False
+
+        build_types_mock.return_value = []
+        self.assertEqual(get_types(self.test_group), {
+            'mouse': {},
+            'human': {}
+        })
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_non_existent_genotype_phenotypes_and_buildtype(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes_exist,
+        genotypes_exist and build_types are truthy
+
+        """
+        phenotypes_exist_mock.return_value = False
+        genotypes_exist_mock.return_value = False
+
+        build_types_mock.return_value = [
+            ['M', 'M', 'Molecular Trait Datasets']
+        ]
+        expected_result = {
+            'mouse': {
+                'H_T2': [['M', 'M', 'Molecular Trait Datasets']],
+                'H_T1': [['M', 'M', 'Molecular Trait Datasets']]},
+            'human': {
+                'HLC': [['M', 'M', 'Molecular Trait Datasets']],
+                'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
+        self.assertEqual(get_types(self.test_group),
+                         expected_result)
-- 
cgit v1.2.3


From b4a6a2cdc523d09334a33ca9a4efe7bc0e77d3de Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 13:14:39 +0300
Subject: Remove unreached "else" branch

* wqflask/wqflask/api/gen_menu.py(get_types):
- Remove unnecessary comment.
- Remove unreachable "else" branch.
---
 wqflask/wqflask/api/gen_menu.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'wqflask')

diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index d265a8ee..e2d8d88a 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -76,11 +76,7 @@ def get_types(groups):
                 types_list = build_types(species, group_name)
                 if len(types_list) > 0:
                     types[species][group_name] += types_list
-                else:
-                    if not phenotypes_exist(group_name) and not genotypes_exist(group_name):
-                        types[species].pop(group_name, None)
-                        groups[species] = list(group for group in groups[species] if group[0] != group_name)
-            else: #ZS: This whole else statement might be unnecessary, need to check
+            else:
                 types_list = build_types(species, group_name)
                 if len(types_list) > 0:
                     types[species][group_name] = types_list
-- 
cgit v1.2.3


From 31e582e4d1e3fc2d36a72f9c775bde40ab61d878 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 15:48:35 +0300
Subject: Update how boolean is returned

* wqflask/wqflask/api/gen_menu.py (get_datasets): convert return value directly
using "bool" to be more general and cater for cases wher "None" is returned
---
 wqflask/wqflask/api/gen_menu.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'wqflask')

diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index e2d8d88a..82c5d9be 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -134,7 +134,7 @@ def get_datasets(types):
             datasets[species][group] = {}
             for type_name in type_list:
                 these_datasets = build_datasets(species, group, type_name[0])
-                if len(these_datasets) > 0:
+                if bool(these_datasets):
                     datasets[species][group][type_name[0]] = these_datasets
 
     return datasets
-- 
cgit v1.2.3


From 899cf35a1dce7ad18645d00238fb39917f8e6e4f Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 15:55:32 +0300
Subject: Add tests for "get_datasets"

* wqflask/tests/api/test_gen_menu.py: Add new tests
---
 wqflask/tests/api/test_gen_menu.py | 74 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

(limited to 'wqflask')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index 0379e297..a606a300 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -5,6 +5,7 @@ import mock
 from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
 from wqflask.api.gen_menu import get_types
+from wqflask.api.gen_menu import get_datasets
 from wqflask.api.gen_menu import phenotypes_exist
 from wqflask.api.gen_menu import genotypes_exist
 from wqflask.api.gen_menu import build_datasets
@@ -30,6 +31,41 @@ class TestGenMenu(unittest.TestCase):
             ]
         }
 
+        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']]
+            }
+        }
+
     @mock.patch('wqflask.api.gen_menu.g')
     def test_get_species(self, db_mock):
         """Test that assertion is raised when dataset and dataset_name are defined"""
@@ -309,3 +345,41 @@ class TestGenMenu(unittest.TestCase):
                 'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
         self.assertEqual(get_types(self.test_group),
                          expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    def test_get_datasets_with_existent_datasets(self,
+                                                 build_datasets_mock):
+        """Test correct dataset is returned with existent build_datasets"""
+        build_datasets_mock.return_value = "Test"
+        expected_result = {
+            'mouse': {
+                'H_T2': {'Genotypes': 'Test',
+                         'M': 'Test',
+                         'Phenotypes': 'Test'},
+                'H_T1': {'Genotypes': 'Test',
+                         'M': 'Test',
+                         'Phenotypes': 'Test'}},
+            'human': {'HLC': {'Genotypes': 'Test',
+                              'M': 'Test',
+                              'Phenotypes': 'Test'},
+                      'BXD': {'Genotypes': 'Test',
+                              'M': 'Test',
+                              'Phenotypes': 'Test'}}}
+        self.maxDiff = None
+        self.assertEqual(get_datasets(self.test_type),
+                         expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    def test_get_datasets_with_non_existent_datasets(self,
+                                                     build_datasets_mock):
+        """Test correct dataset is returned with non-existent build_datasets"""
+        build_datasets_mock.return_value = None
+        expected_result = {
+            'mouse': {
+                'H_T2': {},
+                'H_T1': {}},
+            'human': {'HLC': {},
+                      'BXD': {}}}
+        self.assertEqual(get_datasets(self.test_type),
+                         expected_result)
+
-- 
cgit v1.2.3


From 452f5442fec13afce07997494adc46fb4bbee9d7 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 16:07:08 +0300
Subject: Add test for "gen_dropdown_json"

* wqflask/tests/api/test_gen_menu.py: Add new test
---
 wqflask/tests/api/test_gen_menu.py | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

(limited to 'wqflask')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index a606a300..92485d38 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -2,6 +2,7 @@
 import unittest
 import mock
 
+from wqflask.api.gen_menu import gen_dropdown_json
 from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
 from wqflask.api.gen_menu import get_types
@@ -383,3 +384,31 @@ class TestGenMenu(unittest.TestCase):
         self.assertEqual(get_datasets(self.test_type),
                          expected_result)
 
+    @mock.patch('wqflask.api.gen_menu.get_datasets')
+    @mock.patch('wqflask.api.gen_menu.get_types')
+    @mock.patch('wqflask.api.gen_menu.get_groups')
+    @mock.patch('wqflask.api.gen_menu.get_species')
+    def test_gen_dropdown_json(self,
+                               species_mock,
+                               groups_mock,
+                               types_mock,
+                               datasets_mock):
+        "Test that the correct dictionary is constructed properly"
+        species_mock.return_value = ("speciesA speciesB speciesC speciesD"
+                                     .split(" "))
+        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
+                                      .split(" "))
+        groups_mock.return_value = ("groupA groupB groupC groupD"
+                                    .split(" "))
+        types_mock.return_value = ("typeA typeB typeC typeD"
+                                   .split(" "))
+        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
+                                      .split(" "))
+
+        expected_result = {
+            'datasets': ['datasetA', 'datasetB', 'datasetC', 'datasetD'],
+            'types': ['typeA', 'typeB', 'typeC', 'typeD'],
+            'groups': ['groupA', 'groupB', 'groupC', 'groupD'],
+            'species': ['speciesA', 'speciesB', 'speciesC', 'speciesD']}
+
+        self.assertEqual(gen_dropdown_json(), expected_result)
-- 
cgit v1.2.3


From 30341891c22e2161c1217f808ed05748c91036e2 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 16:46:33 +0300
Subject: Move variable to setUp

* wqflask/tests/api/test_gen_menu.py: Move variable
---
 wqflask/tests/api/test_gen_menu.py | 35 +----------------------------------
 1 file changed, 1 insertion(+), 34 deletions(-)

(limited to 'wqflask')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index 92485d38..ca841708 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -258,40 +258,7 @@ class TestGenMenu(unittest.TestCase):
         phenotypes_exist_mock.return_value = True
         genotypes_exist_mock.return_value = True
 
-        expected_result = {
-            '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']]
-            }
-        }
+        expected_result = self.test_type
 
         build_types_mock.return_value = [
             ['M', 'M', 'Molecular Trait Datasets']
-- 
cgit v1.2.3


From 77a55f3cfe70dfbe319c28380eb16a4f9516366c Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 16:47:42 +0300
Subject: Add extra test for "build_datasets"

* wqflask/tests/api/test_gen_menu.py: Add test.
---
 wqflask/tests/api/test_gen_menu.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

(limited to 'wqflask')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index ca841708..4a928d12 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -178,6 +178,25 @@ class TestGenMenu(unittest.TestCase):
         self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
                          [["None", "BXDPublish", "Mouse Phenome Database"]])
 
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_phenotypes_and_no_results(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type with no
+        results
+
+        """
+        db_mock.db.execute.return_value.fetchall.return_value = None
+        db_mock.db.execute.return_value.fetchone.return_value = (121,
+                                                                 "text value")
+        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
+                         [["None", "121", "text value"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT PublishFreeze.Name, PublishFreeze.FullName "
+            "FROM PublishFreeze, InbredSet "
+            "WHERE InbredSet.Name = 'BXD' AND "
+            "PublishFreeze.InbredSetId = InbredSet.Id "
+            "ORDER BY PublishFreeze.CreateTime ASC"
+        )
+
     @mock.patch('wqflask.api.gen_menu.g')
     def test_build_datasets_with_type_genotypes(self, db_mock):
         """Test that correct dataset is returned for a phenotype type"""
-- 
cgit v1.2.3


From 8fa2d7cc9d3d6599d1c44a6f5e76decf932b2cbd Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 16:54:57 +0300
Subject: Fix some errors generated by running pylint

* wqflask/wqflask/api/gen_menu.py: Apply pylint.
* wqflask/tests/api/test_gen_menu.py: Apply pylint.
---
 wqflask/tests/api/test_gen_menu.py | 33 +++++++++------
 wqflask/wqflask/api/gen_menu.py    | 83 +++++++++++++++++++++-----------------
 2 files changed, 66 insertions(+), 50 deletions(-)

(limited to 'wqflask')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index 4a928d12..79c77fec 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -69,9 +69,11 @@ class TestGenMenu(unittest.TestCase):
 
     @mock.patch('wqflask.api.gen_menu.g')
     def test_get_species(self, db_mock):
-        """Test that assertion is raised when dataset and dataset_name are defined"""
-        db_mock.db.execute.return_value.fetchall.return_value = (('human', 'Human'),
-                                                                 ('mouse', 'Mouse'))
+        """Test that assertion is raised when dataset and dataset_name
+        are defined"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            ('human', 'Human'),
+            ('mouse', 'Mouse'))
         self.assertEqual(get_species(),
                          [['human', 'Human'], ['mouse', 'Mouse']])
         db_mock.db.execute.assert_called_once_with(
@@ -84,7 +86,8 @@ class TestGenMenu(unittest.TestCase):
         db_mock.db.execute.return_value.fetchall.side_effect = [
             # Mouse
             (('BXD', 'BXD', None),
-             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)', 'Test')),
+             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
+              'Test')),
             # Human
             (('H_T1', "H_T", "DescriptionA"),
              ('H_T2', "H_T'", None))
@@ -111,12 +114,14 @@ class TestGenMenu(unittest.TestCase):
         db_mock.db.execute.return_value.fetchone.return_value = None
         phenotypes_exist("test")
         db_mock.db.execute.assert_called_with(
-            "SELECT Name FROM PublishFreeze WHERE PublishFreeze.Name = 'testPublish'"
+            "SELECT Name FROM PublishFreeze "
+            "WHERE PublishFreeze.Name = 'testPublish'"
         )
 
     @mock.patch('wqflask.api.gen_menu.g')
     def test_phenotypes_exist_with_falsy_values(self, db_mock):
-        """Test that phenotype check returns correctly when given a None value"""
+        """Test that phenotype check returns correctly when given
+        a None value"""
         for x in [None, False, (), [], ""]:
             db_mock.db.execute.return_value.fetchone.return_value = x
             self.assertFalse(phenotypes_exist("test"))
@@ -139,7 +144,8 @@ class TestGenMenu(unittest.TestCase):
 
     @mock.patch('wqflask.api.gen_menu.g')
     def test_genotypes_exist_with_falsy_values(self, db_mock):
-        """Test that genotype check returns correctly when given a None value"""
+        """Test that genotype check returns correctly when given
+        a None value"""
         for x in [None, False, (), [], ""]:
             db_mock.db.execute.return_value.fetchone.return_value = x
             self.assertFalse(genotypes_exist("test"))
@@ -151,7 +157,6 @@ class TestGenMenu(unittest.TestCase):
             db_mock.db.execute.return_value.fetchone.return_value = (x)
             self.assertTrue(phenotypes_exist("test"))
 
-
     @mock.patch('wqflask.api.gen_menu.g')
     def test_build_datasets_with_type_phenotypes(self, db_mock):
         """Test that correct dataset is returned for a phenotype type"""
@@ -207,8 +212,9 @@ class TestGenMenu(unittest.TestCase):
         self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
                          [["635", "HLCGeno", "HLC Genotypes"]])
         db_mock.db.execute.assert_called_with(
-            "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, GenoFreeze, InbredSet " +
-            "WHERE InbredSet.Name = 'HLC' AND GenoFreeze.InbredSetId = InbredSet.Id AND " +
+            "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"
         )
@@ -218,7 +224,8 @@ class TestGenMenu(unittest.TestCase):
 
     @mock.patch('wqflask.api.gen_menu.g')
     def test_build_datasets_with_type_mrna(self, db_mock):
-        """Test that correct dataset is returned for a mRNA expression/ Probeset"""
+        """Test that correct dataset is returned for a mRNA
+        expression/ Probeset"""
         db_mock.db.execute.return_value.fetchall.return_value = (
             (112, "HC_M2_0606_P",
              "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
@@ -241,7 +248,8 @@ class TestGenMenu(unittest.TestCase):
     def test_build_types(self, db_mock, datasets_mock):
         """Test that correct tissue metadata is returned"""
         datasets_mock.return_value = [
-            ["112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"]
+            ["112", 'HC_M2_0606_P',
+                "Hippocampus Consortium M430v2 (Jun06) PDNN"]
         ]
         db_mock.db.execute.return_value.fetchall.return_value = (
             ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
@@ -352,7 +360,6 @@ class TestGenMenu(unittest.TestCase):
                       'BXD': {'Genotypes': 'Test',
                               'M': 'Test',
                               'Phenotypes': 'Test'}}}
-        self.maxDiff = None
         self.assertEqual(get_datasets(self.test_type),
                          expected_result)
 
diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index 82c5d9be..45814ed9 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -1,21 +1,12 @@
 from __future__ import print_function, division
 
-import sys
-
 from flask import g
 
-from utility.tools import locate, locate_ignore_error, TEMPDIR, SQL_URI
-from utility.benchmark import Bench
-
-import MySQLdb
-
-import urlparse
-
-import utility.logger
-logger = utility.logger.getLogger(__name__ )
 
 def gen_dropdown_json():
-    """Generates and outputs (as json file) the data for the main dropdown menus on the home page"""
+    """Generates and outputs (as json file) the data for the main dropdown menus on
+    the home page
+    """
 
     species = get_species()
     groups = get_groups(species)
@@ -29,9 +20,11 @@ def gen_dropdown_json():
 
     return data
 
+
 def get_species():
     """Build species list"""
-    results = g.db.execute("SELECT Name, MenuName FROM Species ORDER BY OrderId").fetchall()
+    results = g.db.execute(
+        "SELECT Name, MenuName FROM Species ORDER BY OrderId").fetchall()
 
     species = []
     for result in results:
@@ -39,6 +32,7 @@ def get_species():
 
     return species
 
+
 def get_groups(species):
     """Build groups list"""
     groups = {}
@@ -46,18 +40,23 @@ def get_groups(species):
         groups[species_name] = []
 
         results = g.db.execute(
-            ("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(species_name)).fetchall()
+            ("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(species_name)).fetchall()
 
         for result in results:
             family_name = "Family:" + str(result[2])
-            groups[species_name].append([str(result[0]), str(result[1]), family_name])
+            groups[species_name].append(
+                [str(result[0]), str(result[1]), family_name])
 
     return groups
 
+
 def get_types(groups):
     """Build types list"""
     types = {}
@@ -66,12 +65,15 @@ def get_types(groups):
         types[species] = {}
         for group_name, _group_full_name, _family_name in group_dict:
             if phenotypes_exist(group_name):
-                types[species][group_name] = [("Phenotypes", "Traits and Cofactors", "Phenotypes")]
+                types[species][group_name] = [
+                    ("Phenotypes", "Traits and Cofactors", "Phenotypes")]
             if genotypes_exist(group_name):
                 if group_name in types[species]:
-                    types[species][group_name] += [("Genotypes", "DNA Markers and SNPs", "Genotypes")]
+                    types[species][group_name] += [
+                        ("Genotypes", "DNA Markers and SNPs", "Genotypes")]
                 else:
-                    types[species][group_name] = [("Genotypes", "DNA Markers and SNPs", "Genotypes")]
+                    types[species][group_name] = [
+                        ("Genotypes", "DNA Markers and SNPs", "Genotypes")]
             if group_name in types[species]:
                 types_list = build_types(species, group_name)
                 if len(types_list) > 0:
@@ -82,13 +84,17 @@ def get_types(groups):
                     types[species][group_name] = types_list
                 else:
                     types[species].pop(group_name, None)
-                    groups[species] = list(group for group in groups[species] if group[0] != group_name)
+                    groups[species] = list(
+                        group for group in groups[species]
+                        if group[0] != group_name)
     return types
 
+
 def phenotypes_exist(group_name):
     results = g.db.execute(
-        ("SELECT Name FROM PublishFreeze " +
-         "WHERE PublishFreeze.Name = '{}'").format(group_name+"Publish")).fetchone()
+        ("SELECT Name FROM PublishFreeze "
+         "WHERE PublishFreeze.Name = "
+         "'{}'").format(group_name+"Publish")).fetchone()
     return bool(results)
 
 
@@ -118,13 +124,15 @@ def build_types(species, group):
 
     results = []
     for result in g.db.execute(query).fetchall():
-        if len(result):
+        if bool(result):
             these_datasets = build_datasets(species, group, result[0])
             if len(these_datasets) > 0:
-                results.append([str(result[0]), str(result[0]), "Molecular Trait Datasets"])
+                results.append([str(result[0]), str(result[0]),
+                                "Molecular Trait Datasets"])
 
     return results
 
+
 def get_datasets(types):
     """Build datasets list"""
     datasets = {}
@@ -192,17 +200,18 @@ def build_datasets(species, group, type_name):
         dataset_text = "%s Genotypes" % group
         datasets.append([dataset_id, dataset_value, dataset_text])
 
-    else: # for mRNA expression/ProbeSet
+    else:  # for mRNA expression/ProbeSet
         results = g.db.execute(
-            ("SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " +
-             "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " +
-             "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
-             "Species.Name = '{0}' AND Species.Id = " +
-             "InbredSet.SpeciesId AND InbredSet.Name = '{1}' " +
-             "AND ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
-             "and Tissue.Name = '{2}' AND ProbeFreeze.TissueId = " +
-             "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
-             "ORDER BY ProbeSetFreeze.CreateTime DESC").format(species, group, type_name)).fetchall()
+            ("SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, "
+             "ProbeSetFreeze.FullName FROM ProbeSetFreeze, "
+             "ProbeFreeze, InbredSet, Tissue, Species WHERE "
+             "Species.Name = '{0}' AND Species.Id = "
+             "InbredSet.SpeciesId AND InbredSet.Name = '{1}' "
+             "AND ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id "
+             "and Tissue.Name = '{2}' AND ProbeFreeze.TissueId = "
+             "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id "
+             "ORDER BY ProbeSetFreeze.CreateTime "
+             "DESC").format(species, group, type_name)).fetchall()
 
         datasets = []
         for dataset_info in results:
-- 
cgit v1.2.3


From 549726ec3c4c176f855b65ade299701d1865b261 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 17:11:06 +0300
Subject: Remove "+" when concatenating strings

* wqflask/wqflask/api/gen_menu.py (build_types, build_datasets): Replace '+'
when joining strings inside brackets
---
 wqflask/wqflask/api/gen_menu.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'wqflask')

diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index 45814ed9..cc11e14b 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -113,13 +113,13 @@ def build_types(species, group):
 
     """
 
-    query = ("SELECT DISTINCT Tissue.Name " +
-             "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " +
-             "Tissue, Species WHERE Species.Name = '{0}' " +
-             "AND Species.Id = InbredSet.SpeciesId AND " +
-             "InbredSet.Name = '{1}' AND ProbeFreeze.TissueId = " +
-             "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id " +
-             "AND ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
+    query = ("SELECT DISTINCT Tissue.Name "
+             "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, "
+             "Tissue, Species WHERE Species.Name = '{0}' "
+             "AND Species.Id = InbredSet.SpeciesId AND "
+             "InbredSet.Name = '{1}' AND ProbeFreeze.TissueId = "
+             "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id "
+             "AND ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id "
              "ORDER BY Tissue.Name").format(species, group)
 
     results = []
@@ -154,11 +154,11 @@ def build_datasets(species, group, type_name):
     datasets = []
     if type_name == "Phenotypes":
         results = g.db.execute(
-            ("SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " +
-             "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " +
-             "InbredSet WHERE InbredSet.Name = '{}' AND " +
-             "PublishFreeze.InbredSetId = InbredSet.Id AND " +
-             "InfoFiles.InfoPageName = PublishFreeze.Name " +
+            ("SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, "
+             "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, "
+             "InbredSet WHERE InbredSet.Name = '{}' AND "
+             "PublishFreeze.InbredSetId = InbredSet.Id AND "
+             "InfoFiles.InfoPageName = PublishFreeze.Name "
              "ORDER BY PublishFreeze.CreateTime ASC").format(group)).fetchall()
         if bool(results):
             for result in results:
-- 
cgit v1.2.3