Reorganise the database code

Issue:
https://github.com/genenetwork/gn-gemtext-threads/blob/main/topics/gn1-migration-to-gn2/clustering.gmi

* Reorganise the code to separate the datasets from the traits, and to more
  closely conform to the same flow as that in GN1

1 files changed, 28 insertions, 168 deletions

diff --git a/tests/unit/db/test_traits.py b/tests/unit/db/test_traits.py
index 39d7a31..7d161bf 100644
--- a/tests/unit/db/test_traits.py
+++ b/tests/unit/db/test_traits.py
@@ -2,55 +2,19 @@
 from unittest import mock, TestCase
 from gn3.db.traits import (
     build_trait_name,
-    set_riset_fields,
     set_haveinfo_field,
     update_sample_data,
     retrieve_trait_info,
-    set_geno_riset_fields,
     set_confidential_field,
     set_homologene_id_field,
     retrieve_geno_trait_info,
     retrieve_temp_trait_info,
-    set_publish_riset_fields,
-    set_probeset_riset_fields,
-    retrieve_trait_dataset_name,
     retrieve_publish_trait_info,
     retrieve_probeset_trait_info)
 
 class TestTraitsDBFunctions(TestCase):
     "Test cases for traits functions"
 
-    def test_retrieve_trait_dataset_name(self):
-        """Test that the function is called correctly."""
-        for trait_type, thresh, trait_dataset_name, columns, table in [
-                ["ProbeSet", 9, "testName",
-                 "Id, Name, FullName, ShortName, DataScale", "ProbeSetFreeze"],
-                ["Geno", 3, "genoTraitName", "Id, Name, FullName, ShortName",
-                 "GenoFreeze"],
-                ["Publish", 6, "publishTraitName",
-                 "Id, Name, FullName, ShortName", "PublishFreeze"],
-                ["Temp", 4, "tempTraitName", "Id, Name, FullName, ShortName",
-                 "TempFreeze"]]:
-            db_mock = mock.MagicMock()
-            with self.subTest(trait_type=trait_type):
-                with db_mock.cursor() as cursor:
-                    cursor.fetchone.return_value = (
-                        "testName", "testNameFull", "testNameShort",
-                        "dataScale")
-                    self.assertEqual(
-                        retrieve_trait_dataset_name(
-                            trait_type, thresh, trait_dataset_name, db_mock),
-                        ("testName", "testNameFull", "testNameShort",
-                         "dataScale"))
-                    cursor.execute.assert_called_once_with(
-                        "SELECT %(columns)s "
-                        "FROM %(table)s "
-                        "WHERE public > %(threshold)s AND "
-                        "(Name = %(name)s OR FullName = %(name)s OR ShortName = %(name)s)".format(
-                            cols=columns, ttype=trait_type),
-                        {"threshold": thresh, "name": trait_dataset_name,
-                         "table": table, "columns": columns})
-
     def test_retrieve_publish_trait_info(self):
         """Test retrieval of type `Publish` traits."""
         db_mock = mock.MagicMock()
@@ -159,10 +123,10 @@ class TestTraitsDBFunctions(TestCase):
     def test_build_trait_name_with_good_fullnames(self):
         for fullname, expected in [
                 ["testdb::testname",
-                 {"trait_db": "testdb", "trait_name": "testname", "cellid": "",
-                  "trait_fullname": "testdb::testname"}],
+                 {"db": {"dataset_name": "testdb"}, "trait_name": "testname",
+                  "cellid": "", "trait_fullname": "testdb::testname"}],
                 ["testdb::testname::testcell",
-                 {"trait_db": "testdb", "trait_name": "testname",
+                 {"db": {"dataset_name": "testdb"}, "trait_name": "testname",
                   "cellid": "testcell",
                   "trait_fullname": "testdb::testname::testcell"}]]:
             with self.subTest(fullname=fullname):
@@ -176,26 +140,26 @@ class TestTraitsDBFunctions(TestCase):
 
     def test_retrieve_trait_info(self):
         """Test that information on traits is retrieved as appropriate."""
-        for trait_type, trait_name, trait_dataset_id, trait_dataset_name, expected in [
-                ["Publish", "pubDb::PublishTraitName::pubCell", 1,
-                 "PublishDatasetTraitName",
+        for trait_type, threshold, trait_fullname, expected in [
+                ["Publish", 9, "pubDb::PublishTraitName::pubCell",
                  {"haveinfo": 0, "homologeneid": None, "type": "Publish",
-                  "confidential": 0, "trait_db": "pubDb",
+                  "confidential": 0, "db": {"dataset_name": "pubDb"},
                   "trait_name": "PublishTraitName", "cellid": "pubCell",
                   "trait_fullname": "pubDb::PublishTraitName::pubCell"}],
-                ["ProbeSet", "prbDb::ProbeSetTraitName::prbCell", 2,
-                 "ProbeSetDatasetTraitName",
+                ["ProbeSet", 5, "prbDb::ProbeSetTraitName::prbCell",
                  {"haveinfo": 0, "homologeneid": None, "type": "ProbeSet",
                   "trait_fullname": "prbDb::ProbeSetTraitName::prbCell",
-                  "trait_db": "prbDb", "trait_name": "ProbeSetTraitName",
-                  "cellid": "prbCell"}],
-                ["Geno", "genDb::GenoTraitName", 3, "GenoDatasetTraitName",
+                  "db": {"dataset_name": "prbDb"},
+                  "trait_name": "ProbeSetTraitName", "cellid": "prbCell"}],
+                ["Geno", 12, "genDb::GenoTraitName",
                  {"haveinfo": 0, "homologeneid": None, "type": "Geno",
-                  "trait_fullname": "genDb::GenoTraitName", "trait_db": "genDb",
+                  "trait_fullname": "genDb::GenoTraitName",
+                  "db": {"dataset_name": "genDb"},
                   "trait_name": "GenoTraitName", "cellid": ""}],
-                ["Temp", "tmpDb::TempTraitName", 4, "TempDatasetTraitName",
+                ["Temp", 6, "tmpDb::TempTraitName",
                  {"haveinfo": 0, "homologeneid": None, "type": "Temp",
-                  "trait_fullname": "tmpDb::TempTraitName", "trait_db": "tmpDb",
+                  "trait_fullname": "tmpDb::TempTraitName",
+                  "db": {"dataset_name": "tmpDb"},
                   "trait_name": "TempTraitName", "cellid": ""}]]:
             db_mock = mock.MagicMock()
             with self.subTest(trait_type=trait_type):
@@ -203,8 +167,7 @@ class TestTraitsDBFunctions(TestCase):
                     cursor.fetchone.return_value = tuple()
                     self.assertEqual(
                         retrieve_trait_info(
-                            trait_type, trait_name, trait_dataset_id,
-                            trait_dataset_name, db_mock),
+                            trait_type, threshold, trait_fullname, db_mock),
                         expected)
 
     def test_update_sample_data(self):
@@ -246,128 +209,25 @@ class TestTraitsDBFunctions(TestCase):
 
     def test_set_homologene_id_field(self):
         """Test that the `homologene_id` field is set up correctly"""
-        for trait_info, expected in [
-                [{"type": "Publish"},
-                 {"type": "Publish", "homologeneid": None}],
-                [{"type": "ProbeSet"},
-                 {"type": "ProbeSet", "homologeneid": None}],
-                [{"type": "Geno"}, {"type": "Geno", "homologeneid": None}],
-                [{"type": "Temp"}, {"type": "Temp", "homologeneid": None}]]:
+        for trait_type, trait_info, expected in [
+                ["Publish", {}, {"homologeneid": None}],
+                ["ProbeSet", {}, {"homologeneid": None}],
+                ["Geno", {}, {"homologeneid": None}],
+                ["Temp", {}, {"homologeneid": None}]]:
             db_mock = mock.MagicMock()
             with self.subTest(trait_info=trait_info, expected=expected):
                 with db_mock.cursor() as cursor:
                     cursor.fetchone.return_value = ()
                     self.assertEqual(
-                        set_homologene_id_field(trait_info, db_mock), expected)
+                        set_homologene_id_field(trait_type, trait_info, db_mock), expected)
 
     def test_set_confidential_field(self):
         """Test that the `confidential` field is set up correctly"""
-        for trait_info, expected in [
-                [{"type": "Publish"}, {"type": "Publish", "confidential": 0}],
-                [{"type": "ProbeSet"}, {"type": "ProbeSet"}],
-                [{"type": "Geno"}, {"type": "Geno"}],
-                [{"type": "Temp"}, {"type": "Temp"}]]:
+        for trait_type, trait_info, expected in [
+                ["Publish", {}, {"confidential": 0}],
+                ["ProbeSet", {}, {}],
+                ["Geno", {}, {}],
+                ["Temp", {}, {}]]:
             with self.subTest(trait_info=trait_info, expected=expected):
                 self.assertEqual(
-                    set_confidential_field(trait_info), expected)
-
-    def test_set_geno_riset_fields(self):
-        """
-        Test that the `riset` and `riset_id` fields are retrieved appropriately
-        for the 'Geno' trait type.
-        """
-        for trait_name, expected in [
-                ["testGenoName", ()]]:
-            db_mock = mock.MagicMock()
-            with self.subTest(trait_name=trait_name, expected=expected):
-                with db_mock.cursor() as cursor:
-                    cursor.execute.return_value = ()
-                    self.assertEqual(
-                        set_geno_riset_fields(trait_name, db_mock), expected)
-                    cursor.execute.assert_called_once_with(
-                        (
-                            "SELECT InbredSet.Name, InbredSet.Id"
-                            " FROM InbredSet, GenoFreeze"
-                            " WHERE GenoFreeze.InbredSetId = InbredSet.Id"
-                            " AND GenoFreeze.Name = %(name)s"),
-                        {"name": trait_name})
-
-
-    def test_set_publish_riset_fields(self):
-        """
-        Test that the `riset` and `riset_id` fields are retrieved appropriately
-        for the 'Publish' trait type.
-        """
-        for trait_name, expected in [
-                ["testPublishName", ()]]:
-            db_mock = mock.MagicMock()
-            with self.subTest(trait_name=trait_name, expected=expected):
-                with db_mock.cursor() as cursor:
-                    cursor.execute.return_value = ()
-                    self.assertEqual(
-                        set_publish_riset_fields(trait_name, db_mock), expected)
-                    cursor.execute.assert_called_once_with(
-                        (
-                            "SELECT InbredSet.Name, InbredSet.Id"
-                            " FROM InbredSet, PublishFreeze"
-                            " WHERE PublishFreeze.InbredSetId = InbredSet.Id"
-                            " AND PublishFreeze.Name = %(name)s"),
-                        {"name": trait_name})
-
-
-    def test_set_probeset_riset_fields(self):
-        """
-        Test that the `riset` and `riset_id` fields are retrieved appropriately
-        for the 'ProbeSet' trait type.
-        """
-        for trait_name, expected in [
-                ["testProbeSetName", ()]]:
-            db_mock = mock.MagicMock()
-            with self.subTest(trait_name=trait_name, expected=expected):
-                with db_mock.cursor() as cursor:
-                    cursor.execute.return_value = ()
-                    self.assertEqual(
-                        set_probeset_riset_fields(trait_name, db_mock), expected)
-                    cursor.execute.assert_called_once_with(
-                        (
-                            "SELECT InbredSet.Name, InbredSet.Id"
-                            " FROM InbredSet, ProbeSetFreeze, ProbeFreeze"
-                            " WHERE ProbeFreeze.InbredSetId = InbredSet.Id"
-                            " AND ProbeFreeze.Id = ProbeSetFreeze.ProbeFreezeId"
-                            " AND ProbeSetFreeze.Name = %(name)s"),
-                        {"name": trait_name})
-
-    def test_set_riset_fields(self):
-        """
-        Test that the riset fields are set up correctly for the different trait
-        types.
-        """
-        for trait_info, expected in [
-                [{}, {}],
-                [{"haveinfo": 0, "type": "Publish"},
-                 {"haveinfo": 0, "type": "Publish"}],
-                [{"haveinfo": 0, "type": "ProbeSet"},
-                 {"haveinfo": 0, "type": "ProbeSet"}],
-                [{"haveinfo": 0, "type": "Geno"},
-                 {"haveinfo": 0, "type": "Geno"}],
-                [{"haveinfo": 0, "type": "Temp"},
-                 {"haveinfo": 0, "type": "Temp"}],
-                [{"haveinfo": 1, "type": "Publish", "name": "test"},
-                 {"haveinfo": 1, "type": "Publish", "name": "test",
-                  "riset": "riset_name", "risetid": 0}],
-                [{"haveinfo": 1, "type": "ProbeSet", "name": "test"},
-                 {"haveinfo": 1, "type": "ProbeSet", "name": "test",
-                  "riset": "riset_name", "risetid": 0}],
-                [{"haveinfo": 1, "type": "Geno", "name": "test"},
-                 {"haveinfo": 1, "type": "Geno", "name": "test",
-                  "riset": "riset_name", "risetid": 0}],
-                [{"haveinfo": 1, "type": "Temp", "name": "test"},
-                 {"haveinfo": 1, "type": "Temp", "name": "test", "riset": None,
-                  "risetid": None}]
-        ]:
-            db_mock = mock.MagicMock()
-            with self.subTest(trait_info=trait_info, expected=expected):
-                with db_mock.cursor() as cursor:
-                    cursor.execute.return_value = ("riset_name", 0)
-                    self.assertEqual(
-                        set_riset_fields(trait_info, db_mock), expected)
+                    set_confidential_field(trait_type, trait_info), expected)