deriva 1.7.10__py3-none-any.whl → 1.7.12__py3-none-any.whl

tests/deriva/core/mmo/test_mmo_drop.py

@@ -1,252 +0,0 @@
-"""Unit tests for MMO+DDL Drop operations.
-"""
-import os
-import logging
-from deriva.core import mmo
-from deriva.core.ermrest_model import UpdateMappings
-from tests.deriva.core.mmo.base import BaseMMOTestCase
-
-logger = logging.getLogger(__name__)
-logger.setLevel(os.getenv('DERIVA_PY_TEST_LOGLEVEL', default=logging.WARNING))
-
-
-class TestMMOxDDLDrop (BaseMMOTestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        """Don't bother setting up catalog for the suite.
-        """
-        pass
-
-    def setUp(self):
-        """Setup catalog for each unit test.
-        """
-        TestMMOxDDLDrop.setUpCatalog()
-        super().setUp()
-
-    def test_drop_key(self):
-        kname = ["dept_schema", "dept_dept_no_key"]
-
-        def test():
-            matches = mmo.find(self.model, kname)
-            return len(matches)
-
-        self.assertTrue(test())
-        t = self.model.schemas[kname[0]].tables["dept"]
-        key = t.keys[(t.schema, kname[1])]
-        key.drop(cascade=True, update_mappings=UpdateMappings.immediate)
-        self.assertFalse(test())
-
-    def test_drop_key_deferred(self):
-        kname = ["dept_schema", "dept_dept_no_key"]
-
-        def test(model):
-            matches = mmo.find(model, kname)
-            return len(matches)
-
-        self.assertTrue(test(self.model))
-        t = self.model.schemas[kname[0]].tables["dept"]
-        key = t.keys[(t.schema, kname[1])]
-        key.drop(cascade=True, update_mappings=UpdateMappings.deferred)
-        self.assertTrue(test(self.model.catalog.getCatalogModel()))
-        self.model.apply()
-        self.assertFalse(test(self.model.catalog.getCatalogModel()))
-
-    def test_drop_key_cascade(self):
-        kname = ["dept_schema", "dept_dept_no_key"]
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def test(name):
-            matches = mmo.find(self.model, name)
-            return len(matches)
-
-        self.assertTrue(test(kname))
-        self.assertTrue(test(fkname))
-        t = self.model.schemas[kname[0]].tables["dept"]
-        key = t.keys[(t.schema, kname[1])]
-        key.drop(cascade=True, update_mappings=UpdateMappings.immediate)
-        self.assertFalse(test(kname))
-        self.assertFalse(test(fkname))
-
-    def test_drop_fkey(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def test():
-            matches = mmo.find(self.model, fkname)
-            return len(matches)
-
-        self.assertTrue(test())
-        self.model.fkey(fkname).drop(update_mappings=UpdateMappings.immediate)
-        self.assertFalse(test())
-
-    def test_drop_fkey_deferred(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def test(model):
-            matches = mmo.find(model, fkname)
-            return len(matches)
-
-        self.assertTrue(test(self.model))
-        self.model.fkey(fkname).drop(update_mappings=UpdateMappings.deferred)
-        self.assertTrue(test(self.model.catalog.getCatalogModel()))
-        self.model.apply()
-        self.assertFalse(test(self.model.catalog.getCatalogModel()))
-
-    def test_drop_col(self):
-        cname = ["person_schema", "person", "last_name"]
-
-        def test():
-            matches = mmo.find(self.model, cname)
-            return len(matches)
-
-        self.assertTrue(test())
-        t = self.model.schemas[cname[0]].tables[cname[1]]
-        col = t.columns[cname[2]]
-        col.drop(update_mappings=UpdateMappings.immediate)
-        self.assertFalse(test())
-
-    def test_drop_col_deferred(self):
-        cname = ["person_schema", "person", "last_name"]
-
-        def test(model):
-            matches = mmo.find(model, cname)
-            return len(matches)
-
-        self.assertTrue(test(self.model))
-        t = self.model.schemas[cname[0]].tables[cname[1]]
-        col = t.columns[cname[2]]
-        col.drop(update_mappings=UpdateMappings.deferred)
-        self.assertTrue(test(self.model.catalog.getCatalogModel()))
-        self.model.apply()
-        self.assertFalse(test(self.model.catalog.getCatalogModel()))
-
-    def test_drop_col_cascade_key(self):
-        cname = ["dept_schema", "dept", "dept_no"]
-        kname = ["dept_schema", "dept_dept_no_key"]
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def test(name):
-            matches = mmo.find(self.model, name)
-            return len(matches)
-
-        for name in [cname, kname, fkname]:
-            with self.subTest(f'subTest {name}'):
-                self.assertTrue(test(name))
-
-        t = self.model.schemas[cname[0]].tables[cname[1]]
-        col = t.columns[cname[2]]
-        col.drop(cascade=True, update_mappings=UpdateMappings.immediate)
-        
-        for name in [cname, kname, fkname]:
-            with self.subTest(f'subTest {name}'):
-                self.assertFalse(test(name))
-
-    def test_drop_col_cascade_fkey(self):
-        cname = ["person_schema", "person", "dept"]
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def test(name):
-            matches = mmo.find(self.model, name)
-            return len(matches)
-
-        self.assertTrue(test(cname))
-        self.assertTrue(test(fkname))
-        t = self.model.schemas[cname[0]].tables[cname[1]]
-        col = t.columns[cname[2]]
-        col.drop(cascade=True, update_mappings=UpdateMappings.immediate)
-        self.assertFalse(test(cname))
-        self.assertFalse(test(fkname))
-
-    def test_drop_table_cascade(self):
-        cname = ["dept_schema", "dept", "dept_no"]
-        kname = ["dept_schema", "dept_dept_no_key"]
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def test(name):
-            matches = mmo.find(self.model, name)
-            return len(matches)
-
-        for name in [cname, kname, fkname]:
-            with self.subTest(f'subTest {name}'):
-                self.assertTrue(test(name))
-
-        t = self.model.schemas[cname[0]].tables[cname[1]]
-        t.drop(cascade=True, update_mappings=UpdateMappings.immediate)
-
-        for name in [cname, kname, fkname]:
-            with self.subTest(f'subTest {name}'):
-                self.assertFalse(test(name))
-
-    def test_drop_table_cascade_deferred(self):
-        cname = ["person_schema", "person", "name"]
-        kname = ["person_schema", "person_RID_key"]
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def test(model, name):
-            matches = mmo.find(model, name)
-            return len(matches)
-
-        for name in [cname, kname, fkname]:
-            with self.subTest(f'subtest {name} precondition'):
-                self.assertTrue(test(self.model, name))
-
-        t = self.model.schemas[cname[0]].tables[cname[1]]
-        t.drop(cascade=True, update_mappings=UpdateMappings.deferred)
-
-        # fkname should linger on in the dept table's annotations until the update is applied to the model
-        self.assertTrue(test(self.model.catalog.getCatalogModel(), fkname))
-        self.model.apply()
-        self.assertFalse(test(self.model.catalog.getCatalogModel(), fkname))
-
-    def test_drop_table(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def test(name):
-            matches = mmo.find(self.model, name)
-            return len(matches)
-
-        self.assertTrue(test(fkname))
-        t = self.model.schemas["person_schema"].tables["person"]
-        t.drop(update_mappings=UpdateMappings.immediate)
-        self.assertFalse(test(fkname))
-
-    def test_drop_schema_cascade(self):
-        cname = ["dept_schema", "dept", "dept_no"]
-        kname = ["dept_schema", "dept_dept_no_key"]
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def test(name):
-            matches = mmo.find(self.model, name)
-            return len(matches)
-
-        for name in [cname, kname, fkname]:
-            with self.subTest(f'subtest {name} precondition'):
-                self.assertTrue(test(name))
-
-        s = self.model.schemas[cname[0]]
-        s.drop(cascade=True, update_mappings=UpdateMappings.immediate)
-
-        for name in [cname, kname, fkname]:
-            with self.subTest(f'subtest {name} postcondition'):
-                self.assertFalse(test(name))
-
-    def test_drop_schema_cascade_deferred(self):
-        cname = ["person_schema", "person", "name"]
-        kname = ["person_schema", "person_RID_key"]
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def test(model, name):
-            matches = mmo.find(model, name)
-            return len(matches)
-
-        for name in [cname, kname, fkname]:
-            with self.subTest(f'subtest {name} precondition'):
-                self.assertTrue(test(self.model, name))
-
-        s = self.model.schemas[cname[0]]
-        s.drop(cascade=True, update_mappings=UpdateMappings.deferred)
-
-        # fkname should linger on in the dept table's annotations until the update is applied to the model
-        self.assertTrue(test(self.model.catalog.getCatalogModel(), fkname))
-        self.model.apply()
-        self.assertFalse(test(self.model.catalog.getCatalogModel(), fkname))

tests/deriva/core/mmo/test_mmo_find.py

@@ -1,90 +0,0 @@
-"""Unit tests for MMO find operation.
-"""
-import logging
-import os
-
-from deriva.core import mmo
-from deriva.core.ermrest_model import tag
-from tests.deriva.core.mmo.base import BaseMMOTestCase
-
-logger = logging.getLogger(__name__)
-logger.setLevel(os.getenv('DERIVA_PY_TEST_LOGLEVEL', default=logging.WARNING))
-
-
-def first_element_match(l1, l2):
-    return isinstance(l1, list) and isinstance(l2, list) and \
-        len(l1) == len(l2) and len(l1) > 1 and \
-        l1[0] == l2[0]
-
-
-class TestMMOFind (BaseMMOTestCase):
-
-    def test_find_key_in_vizcols(self):
-        matches = mmo.find(self.model, ["dept_schema", "dept_RID_key"])
-        self.assertEqual(len(matches), 1)
-
-    def test_find_key_in_vizcols_by_schema_only(self):
-        matches = mmo.find(self.model, ["dept_schema", None])
-        self.assertGreater(len(matches), 0)
-
-    def test_find_col_in_vizcols(self):
-        matches = mmo.find(self.model, ["dept_schema", "dept", "RCT"])
-        self.assertEqual(len(matches), 1)
-
-    def test_find_col_in_vizcols_pseudocol_simple(self):
-        matches = mmo.find(self.model, ["dept_schema", "dept", "RMT"])
-        self.assertEqual(len(matches), 1)
-
-    def test_find_col_in_vizcols_pseudocol(self):
-        matches = mmo.find(self.model, ["dept_schema", "dept", "name"])
-        self.assertTrue(any([m.anchor.name == 'person' and m.tag == tag.visible_columns and isinstance(m.mapping, dict) for m in matches]))
-
-    def test_find_col_in_sourcedefs_columns(self):
-        matches = mmo.find(self.model, ["person_schema", "person", "dept"])
-        self.assertTrue(any([m.anchor.name == 'person' and m.tag == tag.source_definitions and m.mapping == 'dept' for m in matches]))
-
-    def test_find_col_in_sourcedefs_sources(self):
-        matches = mmo.find(self.model, ["person_schema", "person", "RID"])
-        self.assertTrue(any([m.tag == tag.source_definitions and m.mapping == 'dept_size' for m in matches]))
-
-    def test_find_fkey_in_vizfkeys(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-        matches = mmo.find(self.model, fkname)
-        self.assertTrue(any([m.tag == tag.visible_foreign_keys and m.mapping == fkname for m in matches]))
-
-    def test_find_fkey_in_vizfkeys_by_schema_only(self):
-        fkname = ["person_schema", None]
-        matches = mmo.find(self.model, fkname)
-        self.assertTrue(any([m.tag == tag.visible_foreign_keys and first_element_match(m.mapping, fkname) for m in matches]))
-
-    def test_find_fkey_in_vizcols(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-        matches = mmo.find(self.model, fkname)
-        self.assertTrue(any([m.tag == tag.visible_columns and m.mapping == fkname for m in matches]))
-
-    def test_find_fkey_in_vizcols_by_schema_only(self):
-        fkname = ["person_schema", None]
-        matches = mmo.find(self.model, fkname)
-        self.assertTrue(any([m.tag == tag.visible_columns and first_element_match(m.mapping, fkname) for m in matches]))
-
-    def test_find_fkey_in_sourcedefs_sources(self):
-        matches = mmo.find(self.model, ["person_schema", "person_dept_fkey"])
-        self.assertTrue(any([m.tag == tag.source_definitions and m.mapping == 'personnel' for m in matches]))
-
-    def test_find_fkey_in_sourcedefs_sources_by_schema_only(self):
-        matches = mmo.find(self.model, ["person_schema", None])
-        self.assertTrue(any([m.tag == tag.source_definitions and m.mapping == 'personnel' for m in matches]))
-
-    def test_find_fkey_in_sourcedefs_fkeys(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-        matches = mmo.find(self.model, fkname)
-        self.assertTrue(any([m.tag == tag.source_definitions and m.mapping == fkname for m in matches]))
-
-    def test_find_fkey_in_sourcedefs_fkeys_by_schema_only(self):
-        fkname = ["person_schema", None]
-        matches = mmo.find(self.model, fkname)
-        self.assertTrue(any([m.tag == tag.source_definitions and m.context == 'fkeys' and first_element_match(m.mapping, fkname) for m in matches]))
-
-    def test_find_col_in_search_box(self):
-        matches = mmo.find(self.model, ["person_schema", "person", "last_name"])
-        self.assertTrue(len(matches) == 1)

tests/deriva/core/mmo/test_mmo_prune.py

@@ -1,196 +0,0 @@
-"""Unit tests for MMO prune operation.
-"""
-import logging
-import os
-
-from deriva.core import mmo
-from deriva.core.ermrest_model import tag
-from tests.deriva.core.mmo.base import BaseMMOTestCase
-
-logger = logging.getLogger(__name__)
-logger.setLevel(os.getenv('DERIVA_PY_TEST_LOGLEVEL', default=logging.WARNING))
-
-
-class TestMMOPrune (BaseMMOTestCase):
-
-    def _pre(self, fn):
-        """Pre-condition evaluation."""
-        fn(self.assertTrue)
-
-    def _post(self, fn):
-        """Post-condition evaluation"""
-        fn(self.assertFalse)
-
-    def test_prune_key_in_vizcols(self):
-        fkname = ["dept_schema", "dept_RID_key"]
-
-        def cond(assertion):
-            matches = mmo.find(self.model, fkname)
-            assertion(len(matches) == 1)
-
-        self._pre(cond)
-        mmo.prune(self.model, fkname)
-        self._post(cond)
-
-    def test_prune_key_in_vizcols_by_schema_only(self):
-        fkname = ["dept_schema", "dept_RID_key"]
-
-        def cond(assertion):
-            matches = mmo.find(self.model, fkname)
-            assertion(len(matches) == 1)
-
-        self._pre(cond)
-        mmo.prune(self.model, [fkname[0], None])
-        self._post(cond)
-
-    def test_prune_col_in_vizcols(self):
-        def cond(assertion):
-            matches = mmo.find(self.model, ["dept_schema", "dept", "RCT"])
-            assertion(len(matches) == 1)
-
-        self._pre(cond)
-        mmo.prune(self.model, ["dept_schema", "dept", "RCT"])
-        self._post(cond)
-
-    def test_prune_col_in_vizcols_pseudocol_simple(self):
-        def cond(assertion):
-            matches = mmo.find(self.model, ["dept_schema", "dept", "RMT"])
-            assertion(len(matches) == 1)
-
-        self._pre(cond)
-        mmo.prune(self.model, ["dept_schema", "dept", "RMT"])
-        self._post(cond)
-
-    def test_prune_col_in_vizcols_pseudocol(self):
-        def cond(assertion):
-            matches = mmo.find(self.model, ["dept_schema", "dept", "name"])
-            assertion(any([m.anchor.name == 'person' and m.tag == tag.visible_columns and isinstance(m.mapping, dict) for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, ["dept_schema", "dept", "name"])
-        self._post(cond)
-
-    def test_prune_col_in_sourcedefs_columns(self):
-        def cond(assertion):
-            matches = mmo.find(self.model, ["person_schema", "person", "dept"])
-            assertion(any([m.anchor.name == 'person' and m.tag == tag.source_definitions and m.mapping == 'dept' for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, ["person_schema", "person", "dept"])
-        self._post(cond)
-
-    def test_prune_col_in_sourcedefs_sources(self):
-        def cond(assertion):
-            matches = mmo.find(self.model, ["person_schema", "person", "RID"])
-            assertion(any([m.tag == tag.source_definitions and m.mapping == 'dept_size' for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, ["person_schema", "person", "RID"])
-        self._post(cond)
-
-    def test_prune_fkey_in_vizfkeys(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def cond(assertion):
-            matches = mmo.find(self.model, fkname)
-            assertion(any([m.tag == tag.visible_foreign_keys and m.mapping == fkname for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, fkname)
-        self._post(cond)
-
-    def test_prune_fkey_in_vizfkeys_by_schema_only(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def cond(assertion):
-            matches = mmo.find(self.model, fkname)
-            assertion(any([m.tag == tag.visible_foreign_keys and m.mapping == fkname for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, [fkname[0], None])
-        self._post(cond)
-
-    def test_prune_fkey_in_vizcols(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def cond(assertion):
-            matches = mmo.find(self.model, fkname)
-            assertion(any([m.tag == tag.visible_columns and m.mapping == fkname for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, fkname)
-        self._post(cond)
-
-    def test_prune_fkey_in_vizcols_by_schema_only(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def cond(assertion):
-            matches = mmo.find(self.model, fkname)
-            assertion(any([m.tag == tag.visible_columns and m.mapping == fkname for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, [fkname[0], None])
-        self._post(cond)
-
-    def test_prune_fkey_in_sourcedefs_sources(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def cond(assertion):
-            matches = mmo.find(self.model, fkname)
-            assertion(any([m.tag == tag.source_definitions and m.mapping == 'personnel' for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, fkname)
-        self._post(cond)
-
-    def test_prune_fkey_in_sourcedefs_sources_by_schema_only(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def cond(assertion):
-            matches = mmo.find(self.model, fkname)
-            assertion(any([m.tag == tag.source_definitions and m.mapping == 'personnel' for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, [fkname[0], None])
-        self._post(cond)
-
-    def test_prune_fkey_in_sourcedefs_fkeys(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def cond(assertion):
-            matches = mmo.find(self.model, fkname)
-            assertion(any([m.tag == tag.source_definitions and m.mapping == fkname for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, fkname)
-        self._post(cond)
-
-    def test_prune_fkey_in_sourcedefs_fkeys_by_schema_only(self):
-        fkname = ["person_schema", "person_dept_fkey"]
-
-        def cond(assertion):
-            matches = mmo.find(self.model, fkname)
-            assertion(any([m.tag == tag.source_definitions and m.mapping == fkname for m in matches]))
-
-        self._pre(cond)
-        mmo.prune(self.model, [fkname[0], None])
-        self._post(cond)
-
-    def test_prune_fkey_in_sourcedefs_recurse(self):
-        def cond(assertion):
-            assertion(any([
-                isinstance(vizcol, dict) and vizcol.get("sourcekey") == "dept_size"
-                for vizcol in self.model.schemas['person_schema'].tables['person'].annotations[tag.visible_columns]['detailed']
-            ]))
-
-        self._pre(cond)
-        mmo.prune(self.model, ["person_schema", "person_dept_fkey"])
-        self._post(cond)
-
-    def test_prune_col_in_search_box(self):
-        def cond(assertion):
-            assertion(len(mmo.find(self.model, ["person_schema", "person", "last_name"])) == 1)
-
-        self._pre(cond)
-        mmo.prune(self.model, ["person_schema", "person", "last_name"])
-        self._post(cond)