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

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)

tests/deriva/core/mmo/test_mmo_rename.py

@@ -1,222 +0,0 @@
-"""Unit tests for MMO+DDL Alter Rename operations.
-"""
-import logging
-import os
-
-from deriva.core import mmo
-from deriva.core.ermrest_model import UpdateMappings, Schema, 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 TestMMOxDDLRename (BaseMMOTestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        """Don't bother setting up catalog for the suite.
-        """
-        pass
-
-    def setUp(self):
-        """Setup catalog for each unit test.
-        """
-        TestMMOxDDLRename.setUpCatalog()
-        super().setUp()
-
-    def _pre(self, fn):
-        """Pre-condition evaluation."""
-        fn(self.assertTrue, self.assertFalse)
-
-    def _post(self, fn):
-        """Post-condition evaluation"""
-        fn(self.assertFalse, self.assertTrue)
-
-    def test_rename_col(self):
-        oldname = "postal_code"
-        newname = "ZIP"
-
-        def cond(before, after):
-            before(len(mmo.find(self.model, ["dept_schema", "dept", oldname])))
-            after(len(mmo.find(self.model, ["dept_schema", "dept", newname])))
-
-        self._pre(cond)
-        self.model.schemas["dept_schema"].tables["dept"].columns[oldname].alter(name=newname, update_mappings=UpdateMappings.immediate)
-        self._post(cond)
-
-    def test_rename_col_deferred(self):
-        oldname = "postal_code"
-        newname = "ZIP"
-
-        def condf(model):
-            def cond(before, after):
-                before(len(mmo.find(model, ["dept_schema", "dept", oldname])))
-                after(len(mmo.find(model, ["dept_schema", "dept", newname])))
-            return cond
-
-        self._pre(condf(self.model))
-        self.model.schemas["dept_schema"].tables["dept"].columns[oldname].alter(name=newname, update_mappings=UpdateMappings.deferred)
-        self._pre(condf(self.model.catalog.getCatalogModel()))
-        self.model.apply()
-        self._post(condf(self.model.catalog.getCatalogModel()))
-
-    def test_rename_key(self):
-        oldname = "dept_dept_no_key"
-        newname = "dept_DEPT_NUM_key"
-
-        def cond(before, after):
-            before(len(mmo.find(self.model, ["dept_schema", oldname])))
-            after(len(mmo.find(self.model, ["dept_schema", newname])))
-
-        self._pre(cond)
-        t = self.model.schemas["dept_schema"].tables["dept"]
-        k = t.keys[(t.schema, oldname)]
-        k.alter(constraint_name=newname, update_mappings=UpdateMappings.immediate)
-        self._post(cond)
-
-    def test_rename_key_deferred(self):
-        oldname = "dept_dept_no_key"
-        newname = "dept_DEPT_NUM_key"
-
-        def condf(model):
-            def cond(before, after):
-                before(len(mmo.find(model, ["dept_schema", oldname])))
-                after(len(mmo.find(model, ["dept_schema", newname])))
-            return cond
-
-        self._pre(condf(self.model))
-        t = self.model.schemas["dept_schema"].tables["dept"]
-        k = t.keys[(t.schema, oldname)]
-        k.alter(constraint_name=newname, update_mappings=UpdateMappings.deferred)
-        self._pre(condf(self.model.catalog.getCatalogModel()))
-        self.model.apply()
-        self._post(condf(self.model.catalog.getCatalogModel()))
-
-    def test_rename_fkey(self):
-        oldname = "person_dept_fkey"
-        newname = "person_department_FKey"
-
-        def cond(before, after):
-            before(len(mmo.find(self.model, ["person_schema", oldname])))
-            after(len(mmo.find(self.model, ["person_schema", newname])))
-
-        self._pre(cond)
-        t = self.model.schemas["person_schema"].tables["person"]
-        fk = t.foreign_keys[(t.schema, oldname)]
-        fk.alter(constraint_name=newname, update_mappings=UpdateMappings.immediate)
-        self._post(cond)
-
-    def test_rename_fkey_deferred(self):
-        oldname = "person_dept_fkey"
-        newname = "person_department_FKey"
-
-        def condf(model):
-            def cond(before, after):
-                before(len(mmo.find(model, ["person_schema", oldname])))
-                after(len(mmo.find(model, ["person_schema", newname])))
-            return cond
-
-        self._pre(condf(self.model))
-        t = self.model.schemas["person_schema"].tables["person"]
-        fk = t.foreign_keys[(t.schema, oldname)]
-        fk.alter(constraint_name=newname, update_mappings=UpdateMappings.deferred)
-        self._pre(condf(self.model.catalog.getCatalogModel()))
-        self.model.apply()
-        self._post(condf(self.model.catalog.getCatalogModel()))
-
-    def _do_test_rename_key_on_table_move(self, deferred=False):
-        oldname = ["dept_schema", "dept_dept_no_key"]
-        newname = ["new_schema", "dept_dept_no_key"]
-
-        def condf(model):
-            def cond(before, after):
-                before(len(mmo.find(model, oldname)))
-                after(len(mmo.find(model, newname)))
-            return cond
-
-        self.model.create_schema(
-            Schema.define(newname[0])
-        )
-
-        self._pre(condf(self.model))
-        t = self.model.schemas[oldname[0]].tables["dept"]
-        t.alter(schema_name=newname[0],
-                update_mappings=UpdateMappings.deferred if deferred else UpdateMappings.immediate)
-        if deferred:
-            self._pre(condf(self.model.catalog.getCatalogModel()))
-            self.model.apply()
-            self._post(condf(self.model.catalog.getCatalogModel()))
-        else:
-            self._post(condf(self.model))
-
-    def test_rename_key_on_table_move(self):
-        self._do_test_rename_key_on_table_move()
-
-    def test_rename_key_on_table_move_deferred(self):
-        self._do_test_rename_key_on_table_move(deferred=True)
-
-    def _do_test_rename_fkey_on_table_move(self, deferred=False):
-        oldname = ["person_schema", "person_dept_fkey"]
-        newname = ["new_schema", "person_dept_fkey"]
-
-        def condf(model):
-            def cond(before, after):
-                before(len(mmo.find(model, oldname)))
-                after(len(mmo.find(model, newname)))
-            return cond
-
-        self.model.create_schema(
-            Schema.define(newname[0])
-        )
-
-        self._pre(condf(self.model))
-        t = self.model.schemas[oldname[0]].tables["person"]
-        t.alter(schema_name=newname[0],
-                update_mappings=UpdateMappings.deferred if deferred else UpdateMappings.immediate)
-        if deferred:
-            self._pre(condf(self.model.catalog.getCatalogModel()))
-            self.model.apply()
-            self._post(condf(self.model.catalog.getCatalogModel()))
-        else:
-            self._post(condf(self.model))
-
-    def test_rename_fkey_on_table_move(self):
-        self._do_test_rename_key_on_table_move()
-
-    def test_rename_fkey_on_table_move_deferred(self):
-        self._do_test_rename_key_on_table_move(deferred=True)
-
-    def _do_test_rename_constraints_on_schema_rename(self, deferred=False):
-        oldfk = ["person_schema", "person_dept_fkey"]
-        newfk = ["new_schema", "person_dept_fkey"]
-        oldk = ["person_schema", "person_RID_key"]
-        newk = ["new_schema", "person_RID_key"]
-
-        def condf(model):
-            def cond(before, after):
-                for tag_name, mapping_before, mapping_after, old_constraint, new_constraint in [
-                    (tag.visible_columns, oldk, newk, oldk, newk),
-                    (tag.visible_foreign_keys, oldfk, newfk, oldfk, newfk),
-                    (tag.source_definitions, 'personnel', 'personnel', oldfk, newfk)
-                ]:
-                    before(any([m.tag == tag_name and m.mapping == mapping_before for m in mmo.find(model, old_constraint)]))
-                    after(any([m.tag == tag_name and m.mapping == mapping_after for m in mmo.find(model, new_constraint)]))
-            return cond
-
-        self._pre(condf(self.model))
-        s = self.model.schemas[oldfk[0]]
-        s.alter(schema_name=newfk[0],
-                update_mappings=UpdateMappings.deferred if deferred else UpdateMappings.immediate)
-        if deferred:
-            self._pre(condf(self.model.catalog.getCatalogModel()))
-            self.model.apply()
-            self._post(condf(self.model.catalog.getCatalogModel()))
-        else:
-            self._post(condf(self.model))
-
-    def test_rename_constraints_on_schema_rename(self):
-        self._do_test_rename_constraints_on_schema_rename()
-
-    def test_rename_constraints_on_schema_rename_deferred(self):
-        self._do_test_rename_constraints_on_schema_rename(deferred=True)

tests/deriva/core/mmo/test_mmo_replace.py

@@ -1,180 +0,0 @@
-"""Unit tests for MMO replace 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 TestMMOReplace (BaseMMOTestCase):
-
-    def _pre(self, fn):
-        """Pre-condition evaluation."""
-        fn(self.assertTrue, self.assertFalse)
-
-    def _post(self, fn):
-        """Post-condition evaluation"""
-        fn(self.assertFalse, self.assertTrue)
-
-    def test_replace_col_in_vizcols(self):
-        def cond(before, after):
-            before(len(mmo.find(self.model, ["dept_schema", "dept", "postal_code"])) == 1)
-            after(len(mmo.find(self.model, ["dept_schema", "dept", "zip"])) == 1)
-
-        self._pre(cond)
-        mmo.replace(self.model, ["dept_schema", "dept", "postal_code"], ["dept_schema", "dept", "zip"])
-        self._post(cond)
-
-    def test_replace_col_in_vizcols_pseudocol_simple(self):
-        def cond(before, after):
-            before(len(mmo.find(self.model, ["dept_schema", "dept", "street_address"])) == 1)
-            after(len(mmo.find(self.model, ["dept_schema", "dept", "number_and_street_name"])) == 1)
-
-        self._pre(cond)
-        mmo.replace(self.model, ["dept_schema", "dept", "street_address"], ["dept_schema", "dept", "number_and_street_name"])
-        self._post(cond)
-
-    def test_replace_col_in_sourcedefs_columns(self):
-        def cond(before, after):
-            before(len(mmo.find(self.model, ["dept_schema", "dept", "country"])) == 1)
-            after(len(mmo.find(self.model, ["dept_schema", "dept", "country_code"])) == 1)
-
-        self._pre(cond)
-        mmo.replace(self.model, ["dept_schema", "dept", "country"], ["dept_schema", "dept", "country_code"])
-        self._post(cond)
-
-    def test_replace_col_in_vizcols_pseudocol(self):
-        def cond(before, after):
-            before(len(mmo.find(self.model, ["dept_schema", "dept", "state"])) == 1)
-            after(len(mmo.find(self.model, ["dept_schema", "dept", "state_or_province"])) == 1)
-
-        self._pre(cond)
-        mmo.replace(self.model, ["dept_schema", "dept", "state"], ["dept_schema", "dept", "state_or_province"])
-        self._post(cond)
-
-    def test_replace_col_in_sourcedefs_sources(self):
-        def cond(before, after):
-            before(len(mmo.find(self.model, ["dept_schema", "dept", "city"])) == 1)
-            after(len(mmo.find(self.model, ["dept_schema", "dept", "township"])) == 1)
-
-        self._pre(cond)
-        mmo.replace(self.model, ["dept_schema", "dept", "city"], ["dept_schema", "dept", "township"])
-        self._post(cond)
-
-    def _do_test_replace_key_in_vizcols(self, oldfk, newfk):
-        replacement = newfk
-        newfk = [replacement[0], replacement[1] if replacement[1] else oldfk[1]]
-
-        def cond(before, after):
-            before(len(mmo.find(self.model, oldfk)) == 1)
-            after(len(mmo.find(self.model, newfk)) == 1)
-
-        self._pre(cond)
-        mmo.replace(self.model, oldfk, replacement)
-        self._post(cond)
-
-    def test_replace_key_in_vizcols(self):
-        self._do_test_replace_key_in_vizcols(["dept_schema", "dept_RID_key"], ["dept_schema", "dept_RID_key1"])
-
-    def test_replace_key_in_vizcols_by_schema_only(self):
-        self._do_test_replace_key_in_vizcols(["dept_schema", "dept_RID_key"], ["new_schema", None])
-
-    def _do_test_replace_fkey_in_vizsrc(self, tagname, oldfk, newfk):
-        replacement = newfk
-        newfk = [replacement[0], replacement[1] if replacement[1] else oldfk[1]]
-
-        def cond(before, after):
-            before(any([m.tag == tagname and m.mapping == oldfk for m in mmo.find(self.model, oldfk)]))
-            after(any([m.tag == tagname and m.mapping == newfk for m in mmo.find(self.model, newfk)]))
-
-        self._pre(cond)
-        mmo.replace(self.model, oldfk, replacement)
-        self._post(cond)
-
-    def test_replace_fkey_in_vizfkeys(self):
-        self._do_test_replace_fkey_in_vizsrc(tag.visible_foreign_keys, ["person_schema", "person_dept_fkey"], ["person_schema", "person_dept_fkey1"])
-
-    def test_replace_fkey_in_vizcols(self):
-        self._do_test_replace_fkey_in_vizsrc(tag.visible_columns, ["person_schema", "person_dept_fkey"], ["person_schema", "person_dept_fkey1"])
-
-    def test_replace_fkey_in_sourcedefs_fkeys(self):
-        self._do_test_replace_fkey_in_vizsrc(tag.source_definitions, ["person_schema", "person_dept_fkey"], ["person_schema", "person_dept_fkey1"])
-
-    def test_replace_fkey_in_vizfkeys_by_schema_only(self):
-        self._do_test_replace_fkey_in_vizsrc(tag.visible_foreign_keys, ["person_schema", "person_dept_fkey"], ["new_schema", None])
-
-    def test_replace_fkey_in_vizcols_by_schema_only(self):
-        self._do_test_replace_fkey_in_vizsrc(tag.visible_columns, ["person_schema", "person_dept_fkey"], ["new_schema", None])
-
-    def test_replace_fkey_in_sourcedefs_fkeys_by_schema_only(self):
-        self._do_test_replace_fkey_in_vizsrc(tag.source_definitions, ["person_schema", "person_dept_fkey"], ["new_schema", None])
-
-    def _do_test_replace_fkey_in_pseudocolumn(self, oldfk, newfk):
-        replacement = newfk
-        newfk = [replacement[0], replacement[1] if replacement[1] else oldfk[1]]
-
-        def cond(before, after):
-            before(any([m.tag == tag.visible_columns and isinstance(m.mapping, dict) for m in mmo.find(self.model, oldfk)]))
-            after(any([m.tag == tag.visible_columns and isinstance(m.mapping, dict) for m in mmo.find(self.model, newfk)]))
-
-        self._pre(cond)
-        mmo.replace(self.model, oldfk, replacement)
-        self._post(cond)
-
-    def test_replace_fkey_in_pseudocolumn(self):
-        self._do_test_replace_fkey_in_pseudocolumn(["person_schema", "person_dept_fkey"], ["person_schema", "person_dept_fkey1"])
-
-    def test_replace_fkey_in_pseudocolumn_by_schema_only(self):
-        self._do_test_replace_fkey_in_pseudocolumn(["person_schema", "person_dept_fkey"], ["new_schema", None])
-
-    def _do_test_replace_fkey_in_sourcedefs_sources(self, oldfk, newfk):
-        replacement = newfk
-        newfk = [replacement[0], replacement[1] if replacement[1] else oldfk[1]]
-
-        def cond(before, after):
-            before(any([m.tag == tag.source_definitions and m.mapping == 'personnel' for m in mmo.find(self.model, oldfk)]))
-            after(any([m.tag == tag.source_definitions and m.mapping == 'personnel' for m in mmo.find(self.model, newfk)]))
-
-        self._pre(cond)
-        mmo.replace(self.model, oldfk, replacement)
-        self._post(cond)
-
-    def test_replace_fkey_in_sourcedefs_sources(self):
-        self._do_test_replace_fkey_in_sourcedefs_sources(["person_schema", "person_dept_fkey"], ["person_schema", "person_dept_fkey1"])
-
-    def test_replace_fkey_in_sourcedefs_sources_by_schema_only(self):
-        self._do_test_replace_fkey_in_sourcedefs_sources(["person_schema", "person_dept_fkey"], ["new_schema", None])
-
-    def test_replace_col_in_search_box(self):
-        def cond(before, after):
-            before(len(mmo.find(self.model, ["person_schema", "person", "last_name"])) == 1)
-            after(len(mmo.find(self.model, ["person_schema", "person", "surname"])) == 1)
-
-        self._pre(cond)
-        mmo.replace(self.model, ["person_schema", "person", "last_name"], ["person_schema", "person", "surname"])
-        self._post(cond)
-
-    def test_replace_all_constraints_by_schema_only(self):
-        oldfk = ["person_schema", "person_dept_fkey"]
-        newfk = ["new_schema", "person_dept_fkey"]
-        oldk = ["person_schema", "person_RID_key"]
-        newk = ["new_schema", "person_RID_key"]
-
-        def cond(before, after):
-            for tag_name, mapping_before, mapping_after, old_constraint, new_constraint in [
-                (tag.visible_columns, oldk, newk, oldk, newk),
-                (tag.visible_foreign_keys, oldfk, newfk, oldfk, newfk),
-                (tag.source_definitions, 'personnel', 'personnel', oldfk, newfk)
-            ]:
-                before(any([m.tag == tag_name and m.mapping == mapping_before for m in mmo.find(self.model, old_constraint)]))
-                after(any([m.tag == tag_name and m.mapping == mapping_after for m in mmo.find(self.model, new_constraint)]))
-
-        self._pre(cond)
-        mmo.replace(self.model, ["person_schema", None], ["new_schema", None])
-        self._post(cond)
-