cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/robotframework/tests/test_locator_manager.py

@@ -0,0 +1,158 @@
+from unittest import mock
+
+import pytest
+
+from cumulusci.robotframework.locator_manager import (
+    LOCATORS,
+    locate_element,
+    register_locators,
+    translate_locator,
+)
+
+mock_libs = {}
+
+
+def mock_get_library_instance(name):
+    mock_libs[name] = mock.Mock(name=name)
+    return mock_libs[name]
+
+
+class TestTranslateLocator:
+    @classmethod
+    def setup_class(cls):
+        LOCATORS.clear()
+        register_locators(
+            prefix="test",
+            locators={
+                "foo": {
+                    "message": "{} {}",
+                    "bar": {
+                        "baz": "//div[@class='baz']",
+                        "hello": "//span[text()='Hello, {}']",
+                    },
+                },
+                "action": "//span[@name='{title}' or @title='{title}']//a[.='{link}']",
+            },
+        )
+
+    def test_named_format_fields(self):
+        """This tests that named format fields are given positional arguments in the correct order"""
+        loc = translate_locator("test", "action:User,Clear")
+        assert loc == "//span[@name='User' or @title='User']//a[.='Clear']"
+
+    def test_strip_whitespace_from_locator(self):
+        """Verify whitespace is stripped from locator key and args"""
+        loc = translate_locator("test", "foo . bar . baz")
+        assert loc == "//div[@class='baz']"
+
+    def test_nested_locators(self):
+        """Verify dot notation can be used to drill into nested structure"""
+        loc = translate_locator("test", "foo.bar.baz")
+        assert loc == "//div[@class='baz']"
+
+    def test_arguments(self):
+        """Verify arguments appear in the final locator"""
+        loc = translate_locator("test", "foo.bar.hello:world")
+        assert loc == "//span[text()='Hello, world']"
+
+    def test_multiple_arguments(self):
+        """Verify we support more than a single argument"""
+        loc = translate_locator("test", "foo.message:hello,world")
+        assert loc == "hello world"
+
+    def test_extra_args(self):
+        """Verify extra args are ignored
+
+        Maybe we should be throwing an error, but since `.format()`
+        doesn't throw an error, we would have to add our own argument
+        checking which I think is more trouble than its worth
+        """
+        loc = translate_locator("test", "foo.message:testing,one,two,three")
+        assert loc == "testing one"
+
+    def test_missing_args(self):
+        """Verify a friendly exception is thrown for missing arguments"""
+        expected_error = "Not enough arguments were supplied"
+        with pytest.raises(Exception, match=expected_error):
+            translate_locator("test", "foo.bar.hello")
+
+    def test_bad_locator(self):
+        """Verify a locator that resolves to a non-string raises an error"""
+        expected_error = "Expected locator to be of type string, but was <class 'dict'>"
+        with pytest.raises(TypeError, match=expected_error):
+            translate_locator("test", "foo.bar")
+
+    def test_unknown_locator(self):
+        """Verify that an invalid locator path throws a useful error
+
+        Not only that, but verify that what appears in the error is
+        the first part of the locator key that wasn't found.
+        """
+        expected_error = "locator test:foo.not not found"
+        with pytest.raises(Exception, match=expected_error):
+            translate_locator("test", "foo.not.valid")
+
+
+class TestLocateElement:
+    @classmethod
+    def setup_class(cls):
+        LOCATORS.clear()
+        register_locators(
+            prefix="test",
+            locators={"foo": {"bar": {"hello": "//span[text()='Hello, {}']"}}},
+        )
+
+    def test_locate_element(self):
+        """Verify that the locate_element function translates the
+        locator and calls SeleniumLibrary.get_webelement with the
+        translated locator.
+
+        That is to say, this verifies that our registered locators
+        are actually usable with Selenium keywords.
+        """
+
+        locator = "foo.bar.hello:world"
+        parent = mock.Mock()
+        tag = ""
+        constraints = {}
+
+        with mock.patch(
+            "robot.libraries.BuiltIn.BuiltIn.get_library_instance",
+            side_effect=mock_get_library_instance,
+        ):
+            locate_element("test", parent, locator, tag, constraints)
+            mock_libs["SeleniumLibrary"].get_webelements.assert_called_with(
+                "//span[text()='Hello, world']"
+            )
+
+
+class TestRegisterLocators:
+    def setup_method(self):
+        LOCATORS.clear()
+
+    def test_register_locators(self):
+        """Verify that register_locators updates the LOCATORS dictionary"""
+        register_locators("test", {"foo": "//div/foo"})
+
+        expected = {"test": {"foo": "//div/foo"}}
+        assert LOCATORS == expected
+
+    def test_multiple_registrations(self):
+        """Verify that more than one prefix can be registered"""
+
+        register_locators("test1", {"foo": "//div/foo"})
+        register_locators("test2", {"bar": "//div/bar"})
+
+        expected = {"test1": {"foo": "//div/foo"}, "test2": {"bar": "//div/bar"}}
+        assert LOCATORS == expected
+
+    def test_register_locators_merge(self):
+        """Verify that calling register_locators will merge the new locators
+        with existing locators for a given prefix, rather than
+        replacing them.
+        """
+        register_locators("test1", {"foo": {"one": "//div/one"}})
+        register_locators("test1", {"foo": {"two": "//div/two"}})
+
+        expected = {"test1": {"foo": {"one": "//div/one", "two": "//div/two"}}}
+        assert LOCATORS == expected

cumulusci/robotframework/tests/test_pageobjects.py

@@ -0,0 +1,291 @@
+"""Tests for the PageObjects class
+
+Testing notes:
+
+The PageObjects library uses robot's BuiltIn library. However,
+instantiating that will throw an error if done outside the context of
+a running robot test. To work around that, these tests mock out the
+_get_context method to fool the BuiltIn library into not complaining.
+
+These tests use two external files in the same directory as this test:
+FooTestPage.py and BarTestPage.py. FooTestPage has a single keyword,
+BarTestPage has two.
+
+"""
+
+import os.path
+import sys
+from contextlib import contextmanager
+from unittest import mock
+
+import pytest
+import robot.utils
+from robot.libraries.BuiltIn import BuiltIn
+
+from cumulusci.robotframework import PageObjects
+from cumulusci.robotframework.CumulusCI import CumulusCI
+from cumulusci.robotframework.pageobjects.BasePageObjects import (
+    DetailPage,
+    HomePage,
+    ListingPage,
+)
+from cumulusci.robotframework.pageobjects.PageObjectLibrary import _PageObjectLibrary
+from cumulusci.utils import temporary_dir
+
+HERE = os.path.dirname(__file__)
+FOO_PATH = os.path.join(HERE, "FooTestPage.py")
+CUSTOM_PATH = os.path.join(HERE, "CustomObjectTestPage.py")
+
+# this is the importer used by the page objects, which makes it easy
+# peasy to import by file path
+importer = robot.utils.Importer()
+
+# These tests don't need an org, so mocking it out will prevent some
+# keywords from trying to create the org.
+cci_lib = CumulusCI()
+cci_lib._org = mock.Mock()
+
+
+class MockGetLibraryInstance:
+    """Mock robot's get_library_instance method
+
+    This will return instances of the libraries used in this set of tests.
+    """
+
+    libs = {
+        "SeleniumLibrary": mock.Mock(),
+        "cumulusci.robotframework.CumulusCI": cci_lib,
+        "cumulusci.robotframework.Salesforce": mock.Mock(),
+        "cumulusci.robotframework.SalesforceAPI": mock.Mock(),
+        # Note: the fact that we're using "Contact" here is largely
+        # irrelevant. The important thing is that we create a page
+        # object for the base types of Home, Listing,and Detail
+        "ContactHomePage": _PageObjectLibrary(HomePage("Contact")),
+        "ContactListingPage": _PageObjectLibrary(ListingPage("Contact")),
+        "ContactDetailPage": _PageObjectLibrary(DetailPage("Contact")),
+    }
+
+    def __call__(self, libname):
+        if libname in self.libs:
+            return self.libs[libname]
+        else:
+            raise Exception("unknown library: {}".format(libname))
+
+
+@contextmanager
+def reload_PageObjects(*args):
+    # Reset the registry and re-import the built-in page objects
+    saved_registry = PageObjects.registry
+    PageObjects._reset()
+    import cumulusci.robotframework.pageobjects.BasePageObjects  # noqa: F401
+    import cumulusci.robotframework.pageobjects.ObjectManagerPageObject  # noqa: F401
+
+    yield PageObjects(*args)
+
+    PageObjects._reset()
+    PageObjects.registry = saved_registry
+
+
+@mock.patch(
+    "robot.libraries.BuiltIn.BuiltIn.get_library_instance",
+    side_effect=MockGetLibraryInstance(),
+)
+# We have to mock out _get_context or the robot libraries will
+# throw an exception saying it cannot access the execution context.
+@mock.patch("robot.libraries.BuiltIn.BuiltIn._get_context")
+class TestPageObjects:
+    def test_PageObject(self, get_context_mock, get_library_instance_mock):
+        """Smoke test to make sure the default registry is set up and keywords exist"""
+
+        with reload_PageObjects() as po:
+            expected_keywords = [
+                "current_page_should_be",
+                "get_page_object",
+                "go_to_page",
+                "load_page_object",
+                "log_page_object_keywords",
+                "wait_for_modal",
+                "wait_for_page_object",
+            ]
+            actual_keywords = po.get_keyword_names()
+            assert actual_keywords == expected_keywords
+
+            # fmt: off
+            # This is much easier to read than if black were to reformat it.
+            expected_registry = {
+                ("Detail", ""): "<class 'cumulusci.robotframework.pageobjects.BasePageObjects.DetailPage'>",
+                ("Edit", ""): "<class 'cumulusci.robotframework.pageobjects.BasePageObjects.EditModal'>",
+                ("Home", ""): "<class 'cumulusci.robotframework.pageobjects.BasePageObjects.HomePage'>",
+                ("Listing", ""): "<class 'cumulusci.robotframework.pageobjects.BasePageObjects.ListingPage'>",
+                ("New", ""): "<class 'cumulusci.robotframework.pageobjects.BasePageObjects.NewModal'>",
+                ("ObjectManager", ""): "<class 'cumulusci.robotframework.pageobjects.ObjectManagerPageObject.ObjectManagerPage'>",
+            }
+            # fmt: on
+            actual_registry = {key: repr(value) for key, value in po.registry.items()}
+            assert actual_registry == expected_registry
+
+    def test_file_in_pythonpath(self, get_context_mock, get_library_instance_mock):
+        """Verify we can find a page object via PYTHONPATH"""
+        # PageObjects will throw an error if it can't find the file.
+        # As long as this doesn't throw an error, we're golden.
+        sys_path = sys.path.copy()
+        if HERE not in sys.path:
+            sys_path.append(HERE)
+        with mock.patch.object(sys, "path", sys_path):
+            PageObjects("FooTestPage.py")
+
+    def test_exception_not_found(self, get_context_mock, get_library_instance_mock):
+        """Verify we get an assertion of we can't find a page object file"""
+        with pytest.raises(
+            ImportError, match="Unable to find page object file 'bogus.py'"
+        ):
+            PageObjects("bogus.py")
+
+    def test_import_failed(self, get_context_mock, get_library_instance_mock):
+        with temporary_dir() as d:
+            with open("busted.py", "w") as f:
+                f.write("class Busted  # incomplete class\n")
+                f.close()
+                with mock.patch.object(sys, "path", sys.path + [d]):
+                    with pytest.raises(
+                        ImportError,
+                        match="Unable to import page object 'busted.py': .*",
+                    ):
+                        PageObjects("busted.py")
+
+    def test_PageObject_registry_with_custom_pageobjects(
+        self, get_context_mock, get_library_instance_mock
+    ):
+        """Verify that custom page objects get added to the registry"""
+        with reload_PageObjects(FOO_PATH, CUSTOM_PATH) as po:
+            # fmt: off
+            # This is much easier to read than if black were to reformat it.
+            expected_registry = {
+                ("Detail", ""): "<class 'cumulusci.robotframework.pageobjects.BasePageObjects.DetailPage'>",
+                ("Edit", ""): "<class 'cumulusci.robotframework.pageobjects.BasePageObjects.EditModal'>",
+                ("Home", ""): "<class 'cumulusci.robotframework.pageobjects.BasePageObjects.HomePage'>",
+                ("Listing", ""): "<class 'cumulusci.robotframework.pageobjects.BasePageObjects.ListingPage'>",
+                ("New", ""): "<class 'cumulusci.robotframework.pageobjects.BasePageObjects.NewModal'>",
+                ("ObjectManager", ""): "<class 'cumulusci.robotframework.pageobjects.ObjectManagerPageObject.ObjectManagerPage'>",
+                # the custom page object uses an alias for the object name so it will be in the registry twice
+                ("Listing", "CustomObject__c"): "<class 'CustomObjectTestPage.CustomObjectListingPage'>",
+                ("Listing", "Custom Object"): "<class 'CustomObjectTestPage.CustomObjectListingPage'>",
+                ("Test", "Foo__c"): "<class 'FooTestPage.FooTestPage'>",
+            }
+            # fmt: on
+            actual_registry = {key: repr(value) for key, value in po.registry.items()}
+            assert actual_registry == expected_registry
+
+    def test_namespaced_object_name(self, get_context_mock, get_library_instance_mock):
+        """Verify that the object name is prefixed by the namespace when there's a namespace"""
+        with mock.patch.object(
+            CumulusCI, "get_namespace_prefix", return_value="foobar__"
+        ):
+            with reload_PageObjects(FOO_PATH) as po:
+
+                FooTestPage = importer.import_class_or_module_by_path(FOO_PATH)
+                MockGetLibraryInstance.libs["FooTestPage"] = _PageObjectLibrary(
+                    FooTestPage()
+                )
+
+                pobj = po.get_page_object("Test", "Foo__c")
+                assert pobj.object_name == "foobar__Foo__c"
+
+    def test_non_namespaced_object_name(
+        self, get_context_mock, get_library_instance_mock
+    ):
+        """Verify that the object name is not prefixed by a namespace when there is no namespace"""
+        with mock.patch.object(CumulusCI, "get_namespace_prefix", return_value=""):
+            with reload_PageObjects(FOO_PATH) as po:
+
+                FooTestPage = importer.import_class_or_module_by_path(FOO_PATH)
+                MockGetLibraryInstance.libs["FooTestPage"] = _PageObjectLibrary(
+                    FooTestPage()
+                )
+
+                pobj = po.get_page_object("Test", "Foo__c")
+                assert pobj.object_name == "Foo__c"
+
+    def test_go_to_page_with_locator(self, get_context_mock, get_library_instance_mock):
+        """Verify 'Go to page' accepts and uses a locator argument
+
+        See W-8580487 for more details
+        """
+
+        with reload_PageObjects() as po:
+            for page_type in ("Home", "Listing", "Detail"):
+                # the exact locator isn't important for the test, we
+                # just need to make sure it is passed on to
+                # wait_until_loading_is_complete
+                locator = f"//div[@class='{page_type}']"
+                po.go_to_page(page_type, "Contact", locator=locator)
+                sflib = BuiltIn().get_library_instance(
+                    "cumulusci.robotframework.Salesforce"
+                )
+                sflib.wait_until_loading_is_complete.assert_called_with(locator=locator)
+
+    def test_go_to_page_without_locator(
+        self, get_context_mock, get_library_instance_mock
+    ):
+        """Verify 'Go to page' doesn't require a locator"""
+
+        with reload_PageObjects() as po:
+            for page_type in ("Home", "Listing", "Detail"):
+                po.go_to_page(page_type, "Contact")
+                sflib = BuiltIn().get_library_instance(
+                    "cumulusci.robotframework.Salesforce"
+                )
+                sflib.wait_until_loading_is_complete.assert_called_with(locator=None)
+
+
+@mock.patch(
+    "robot.libraries.BuiltIn.BuiltIn.get_library_instance",
+    side_effect=MockGetLibraryInstance(),
+)
+class TestBasePage:
+    """Some low-level tests of page object classes"""
+
+    def test_no_implicit_wait(self, mock_get_library_instance):
+        """Verify the "implicit wait" context manager restores the value"""
+
+        selib = BuiltIn().get_library_instance("SeleniumLibrary")
+        selib.set_selenium_implicit_wait.return_value = 7
+        selib.set_selenium_implicit_wait.reset_mock()
+
+        from cumulusci.robotframework.pageobjects import BasePage
+
+        page = BasePage()
+        with page._no_implicit_wait():
+            pass
+
+        # The first call should pass in zero to turn off the
+        # implicit wait.  We've configured the mocked function to
+        # return '7'. The second call should pass the return value
+        # of the first call
+        selib.set_selenium_implicit_wait.assert_has_calls(
+            (mock.call(0), mock.call(7)), any_order=False
+        )
+
+    def test_no_implicit_wait_with_exception(self, mock_get_library_instance):
+        """Verify the "implicit wait" context manager restores the value even if exception occurs"""
+
+        selib = BuiltIn().get_library_instance("SeleniumLibrary")
+        selib.set_selenium_implicit_wait.return_value = 42
+        selib.set_selenium_implicit_wait.reset_mock()
+
+        from cumulusci.robotframework.pageobjects import BasePage
+
+        page = BasePage()
+        try:
+            with page._no_implicit_wait():
+                raise Exception("Danger Will Robinson!")
+        except Exception:
+            pass
+
+        # The first call should pass in zero to turn off the
+        # implicit wait.  We've configured the mocked function to
+        # return '42'. The second call should pass the return value
+        # of the first call
+        selib.set_selenium_implicit_wait.assert_has_calls(
+            (mock.call(0), mock.call(42)), any_order=False
+        )

cumulusci/robotframework/tests/test_performance.py

@@ -0,0 +1,38 @@
+from unittest import mock
+
+import pytest
+
+from cumulusci.robotframework.Performance import Performance
+from cumulusci.robotframework.SalesforceAPI import SalesforceAPI
+
+
+class TestKeyword_elapsed_time_for_last_record:
+    def test_elapsed_time_for_last_record__query_empty(self):
+        perflib = Performance()
+        records = {"records": []}
+
+        with mock.patch.object(perflib, "_salesforce_api", SalesforceAPI()):
+            with mock.patch.object(SalesforceAPI, "cumulusci") as cumulusci:
+                cumulusci.sf.query_all.return_value = records
+                with pytest.raises(Exception) as e:
+                    perflib.elapsed_time_for_last_record("FOO", "Bar", "Baz", "Baz")
+                assert "Matching record not found" in str(e.value)
+
+    def test_elapsed_time_for_last_record__query_returns_result(self):
+        perflib = Performance()
+        records = {
+            "records": [
+                {
+                    "CreatedDate": "2020-12-29T10:00:01.000+0000",
+                    "CompletedDate": "2020-12-29T10:00:04.000+0000",
+                }
+            ],
+        }
+
+        with mock.patch.object(perflib, "_salesforce_api", SalesforceAPI()):
+            with mock.patch.object(SalesforceAPI, "cumulusci") as cumulusci:
+                cumulusci.sf.query_all.return_value = records
+                elapsed = perflib.elapsed_time_for_last_record(
+                    "AsyncApexJob", "CreatedDate", "CompletedDate", "CompletedDate"
+                )
+                assert elapsed == 3

cumulusci/robotframework/tests/test_salesforce.py

@@ -0,0 +1,79 @@
+from unittest import mock
+
+import pytest
+from SeleniumLibrary.errors import ElementNotFound
+
+from cumulusci.robotframework.Salesforce import Salesforce
+
+
+# _init_locators has a special code block
+class TestSeleniumLibrary:
+    def test_init_locators(self):
+        """Verify that locators are initialized if not passed in"""
+        with mock.patch.object(Salesforce, "_init_locators"):
+            # _init_locators should NOT be called if we pass them in
+            sflib = Salesforce(locators={"body": "//whatever"})
+            assert not sflib._init_locators.called
+
+            # _init_locators SHOULD be called if we don't pass them in
+            sflib = Salesforce()
+            sflib._init_locators.assert_called_once()
+
+
+@mock.patch("robot.libraries.BuiltIn.BuiltIn._get_context")
+class TestKeyword_wait_until_salesforce_is_ready:
+    @classmethod
+    def setup_class(cls):
+        cls.sflib = Salesforce(locators={"body": "//whatever"})
+
+    def test_successful_page_load(self, mock_robot_context):
+        """Verify that a succesful page load returns no errors"""
+        with mock.patch.object(Salesforce, "wait_for_aura", return_value=True):
+            self.sflib.wait_until_salesforce_is_ready(timeout="1")
+
+            self.sflib.wait_for_aura.assert_called_once()
+            self.sflib.selenium.get_webelement.assert_called_once_with("//whatever")
+
+    def test_reload_on_initial_failure(self, mock_robot_context):
+        """Verify that we attempt a reload when we don't find the lightning component"""
+        with mock.patch.object(Salesforce, "wait_for_aura", return_value=True):
+            with mock.patch.object(
+                Salesforce, "_check_for_classic", return_value=False
+            ):
+                with mock.patch.object(
+                    Salesforce, "_check_for_login_failure", return_value=False
+                ):
+                    with mock.patch.object(
+                        self.sflib.selenium,
+                        "get_webelement",
+                        side_effect=(ElementNotFound(), True),
+                    ):
+                        self.sflib.wait_until_salesforce_is_ready(timeout="10")
+                        self.sflib.selenium.go_to.assert_called_once()
+
+    def test_exception_and_screenshot_on_timeout(self, mock_robot_context):
+        """Verify that we throw an appropriate exception after the timeout"""
+        with mock.patch.object(Salesforce, "wait_for_aura", return_value=True):
+            self.sflib.selenium.get_webelement.side_effect = ElementNotFound()
+
+            with pytest.raises(
+                Exception, match="Timed out waiting for a lightning page"
+            ):
+                # The timeout needs to be longer than the duration of
+                # one loop iteration, but less than the retry interval
+                # of 5 seconds. Making it longer should still pass the
+                # test, it just makes the test run longer than necessary.
+                self.sflib.wait_until_salesforce_is_ready(timeout=0.1)
+
+            self.sflib.selenium.capture_page_screenshot.assert_called()
+
+
+@mock.patch("robot.libraries.BuiltIn.BuiltIn._get_context")
+class TestKeyword_breakpoint:
+    @classmethod
+    def setup_class(cls):
+        cls.sflib = Salesforce(locators={"body": "//whatever"})
+
+    def test_breakpoint(self, mock_robot_context):
+        """Verify that the keyword doesn't raise an exception"""
+        assert self.sflib.breakpoint() is None

cumulusci/robotframework/tests/test_salesforce_locators.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+from unittest import mock
+
+from robot.libraries.BuiltIn import RobotNotRunningError
+
+from cumulusci.robotframework.Salesforce import Salesforce
+
+
+# FIXME: we shouldn't have to tweak these tests for every
+# version. The tests should be smarter.
+class TestLocators:
+    @mock.patch(
+        "cumulusci.robotframework.SalesforceAPI.SalesforceAPI.get_latest_api_version"
+    )
+    def test_locators_in_robot_context(self, get_latest_api_version):
+        """Verify we can get locators for the current org api version"""
+        get_latest_api_version.return_value = 57.0
+
+        # This instantiates the robot library, mimicking a robot library import.
+        # We've mocked out the code that would otherwise throw an error since
+        # we're not running in the context of a robot test. The library should
+        # return the latest version of the locators.
+        sf = Salesforce()
+
+        expected = "cumulusci.robotframework.locators_57"
+        actual = sf.locators_module.__name__
+        message = "expected to load '{}', actually loaded '{}'".format(expected, actual)
+        assert expected == actual, message
+
+    @mock.patch(
+        "robot.libraries.BuiltIn.BuiltIn.get_library_instance",
+        side_effect=RobotNotRunningError(),
+    )
+    def test_locators_outside_robot_context(self, builtin_mock):
+        """Verify that we get the latest locators if not running in the context of a robot test"""
+
+        # This instantiates the robot library, mimicing a robot library import
+        # however, because we've mocked get_library_instance to throw an error,
+        # we expect the library to still be instantiated, but with the latest
+        # version of the locators.
+
+        sf = Salesforce()
+
+        locator_folder = Path("./cumulusci/robotframework")
+        locator_modules = sorted(locator_folder.glob("locators_[0-9][0-9].py"))
+        expected = f"cumulusci.robotframework.{locator_modules[-1].stem}"
+
+        actual = sf.locators_module.__name__
+        message = "expected to load '{}', actually loaded '{}'".format(expected, actual)
+        assert expected == actual, message
+
+    def test_locators_57(self):
+        """Verify that locators_57 is a superset of the locators_56
+
+        This test is far from perfect, but it should at least flag a
+        catastrophic error in how locators for a version that augments
+        the locators from previous versions.
+
+        Note: this test assumes that locators_56 doesn't delete any of the
+        keys from 54.
+
+        """
+        import cumulusci.robotframework.locators_56 as locators_56
+        import cumulusci.robotframework.locators_57 as locators_57
+
+        keys_56 = set(locators_56.lex_locators)
+        keys_57 = set(locators_57.lex_locators)
+
+        assert id(locators_56.lex_locators) != id(
+            locators_57.lex_locators
+        ), "locators_56.lex_locators and locators_57.lex_locators are the same object"
+        assert len(keys_56) > 0
+        assert keys_57.issubset(keys_56)