def test_name_matches_object_identity(self):
        generator = utils.RandomNameGeneratorMixin()
        generator.task = {"uuid": "faketask"}

        self.assertTrue(utils.name_matches_object(
            generator.generate_random_name(), generator))
        self.assertTrue(utils.name_matches_object(
            generator.generate_random_name(), utils.RandomNameGeneratorMixin))

 def test_name_matches_object_kwargs(self):
     name = "foo"
     obj = mock.Mock()
     self.assertTrue(utils.name_matches_object(name, obj, task_id="taskid",
                                               exact=False))
     obj.name_matches_object.assert_called_once_with(name, task_id="taskid",
                                                     exact=False)

 def test_name_matches_object(self, mock_name_matches_pattern):
     name = "foo"
     self.assertTrue(
         utils.name_matches_object(name, utils.RandomNameGeneratorMixin))
     mock_name_matches_pattern.assert_called_once_with(
         name,
         utils.RandomNameGeneratorMixin.RESOURCE_NAME_FORMAT,
         utils.RandomNameGeneratorMixin.RESOURCE_NAME_ALLOWED_CHARACTERS)

 def list(self):
     # NOTE(stpierre): any plugin can create a nova network via the
     # network wrapper, and that network's name will be created
     # according to its owner's random name generation
     # parameters. so we need to check if there are nova networks
     # whose name pattern matches those of any loaded plugin that
     # implements RandomNameGeneratorMixin
     classes = list(discover.itersubclasses(utils.RandomNameGeneratorMixin))
     return [net for net in self._manager().list()
             if utils.name_matches_object(net.label, *classes)]

    def test_name_matches_object_identical_list(self, mock_name_matches_pattern):
        class One(utils.RandomNameGeneratorMixin):
            pass

        class Two(utils.RandomNameGeneratorMixin):
            pass

        name = "foo"
        self.assertFalse(utils.name_matches_object(name, One, Two))
        mock_name_matches_pattern.assert_called_once_with(
            name, One.RESOURCE_NAME_FORMAT, One.RESOURCE_NAME_ALLOWED_CHARACTERS
        )

    def test_name_matches_object_identical_list(self):
        class One(utils.RandomNameGeneratorMixin):
            name_matches_object = mock.Mock(return_value=False)

        class Two(utils.RandomNameGeneratorMixin):
            name_matches_object = mock.Mock(return_value=False)

        name = "foo"
        self.assertFalse(utils.name_matches_object(name, One, Two))
        # ensure that exactly one of the two objects is checked
        self.assertItemsEqual(
            One.name_matches_object.call_args_list +
            Two.name_matches_object.call_args_list,
            [mock.call(name)])

    def _consumer(self, cache, args):
        """Method that consumes single deletion job."""
        admin, user, raw_resource = args

        manager = self.manager_cls(
            resource=raw_resource,
            admin=self._get_cached_client(admin),
            user=self._get_cached_client(user),
            tenant_uuid=user and user["tenant_id"])

        if (isinstance(manager.name(), base.NoName) or
                rutils.name_matches_object(
                    manager.name(), *self.resource_classes,
                    task_id=self.task_id, exact=False)):
            self._delete_single_resource(manager)

    def test_name_matches_object_differing_list(self, mock_name_matches_pattern):
        class One(utils.RandomNameGeneratorMixin):
            pass

        class Two(utils.RandomNameGeneratorMixin):
            RESOURCE_NAME_FORMAT = "foo_XXX_XXX"

        class Three(utils.RandomNameGeneratorMixin):
            RESOURCE_NAME_ALLOWED_CHARACTERS = "12345"

        class Four(utils.RandomNameGeneratorMixin):
            RESOURCE_NAME_FORMAT = "bar_XXX_XXX"
            RESOURCE_NAME_ALLOWED_CHARACTERS = "abcdef"

        classes = (One, Two, Three, Four)
        name = "foo"
        self.assertFalse(utils.name_matches_object(name, *classes))
        calls = [mock.call(name, cls.RESOURCE_NAME_FORMAT, cls.RESOURCE_NAME_ALLOWED_CHARACTERS) for cls in classes]
        mock_name_matches_pattern.assert_has_calls(calls, any_order=True)

    def test_name_matches_object_differing_list(self):
        class One(utils.RandomNameGeneratorMixin):
            name_matches_object = mock.Mock(return_value=False)

        class Two(utils.RandomNameGeneratorMixin):
            RESOURCE_NAME_FORMAT = "foo_XXX_XXX"
            name_matches_object = mock.Mock(return_value=False)

        class Three(utils.RandomNameGeneratorMixin):
            RESOURCE_NAME_ALLOWED_CHARACTERS = "12345"
            name_matches_object = mock.Mock(return_value=False)

        class Four(utils.RandomNameGeneratorMixin):
            RESOURCE_NAME_FORMAT = "bar_XXX_XXX"
            RESOURCE_NAME_ALLOWED_CHARACTERS = "abcdef"
            name_matches_object = mock.Mock(return_value=False)

        classes = (One, Two, Three, Four)
        name = "foo"
        self.assertFalse(utils.name_matches_object(name, *classes))
        for cls in classes:
            cls.name_matches_object.assert_called_once_with(name)

def is_temporary(resource):
    return utils.name_matches_object(resource.name, KeystoneScenario)

 def test_name_matches_object(self):
     name = "foo"
     obj = mock.Mock()
     self.assertTrue(utils.name_matches_object(name, obj))
     obj.name_matches_object.assert_called_once_with(name)

 def list(self):
     return [net for net in self._manager().list()
             if (utils.name_matches_object(net.label,
                                           nova_utils.NovaScenario) or
                 net.label.startswith("rally_novanet"))]