def test_entries_for_tenant_internal(self):
        """
        Validate that the internal API shows up in the service catalog for a
        given tenant.
        """
        iapi = make_example_internal_api(self)
        core = MimicCore(Clock(), [iapi])

        prefix_map = {}
        base_uri = "http://some/random/prefix"
        catalog_entries = [
            entry
            for entry in core.entries_for_tenant(
                'some-tenant',
                prefix_map,
                base_uri
            )
        ]

        self.assertEqual(len(core._uuid_to_api_internal), 1)
        self.assertEqual(len(core._uuid_to_api_external), 0)
        self.assertEqual(len(catalog_entries), 1)
        self.assertEqual(catalog_entries[0].type, "serviceType")
        self.assertEqual(catalog_entries[0].name, "serviceName")
        self.assertEqual(catalog_entries[0].tenant_id, "some-tenant")
        self.assertEqual(len(catalog_entries[0].endpoints), 1)

    def test_auth_accepts_tenant_name(self):
        """
        If "tenantName" is passed, the tenant specified is used instead of a
        generated tenant ID.
        """
        core = MimicCore(Clock(), [])
        root = MimicRoot(core).app.resource()

        (response, json_body) = self.successResultOf(json_request(
            self, root, "POST", "/identity/v2.0/tokens",
            {
                "auth": {
                    "passwordCredentials": {
                        "username": "demoauthor",
                        "password": "theUsersPassword"
                    },
                    "tenantName": "turtlepower"
                }
            }
        ))

        self.assertEqual(200, response.code)
        self.assertEqual("turtlepower",
                         json_body['access']['token']['tenant']['id'])
        token = json_body['access']['token']['id']
        session = core.session_for_token(token)
        self.assertEqual(token, session.token)
        self.assertEqual("turtlepower", session.tenant_id)

    def test_response_has_auth_token(self):
        """
        The JSON response has a access.token.id key corresponding to its
        MimicCore session, and therefore access.token.tenant.id should match
        that session's tenant_id.
        """
        core = MimicCore(Clock(), [])
        root = MimicRoot(core).app.resource()

        (response, json_body) = self.successResultOf(json_request(
            self, root, "POST", "/identity/v2.0/tokens",
            {
                "auth": {
                    "passwordCredentials": {
                        "username": "demoauthor",
                        "password": "theUsersPassword"
                    }

                }
            }
        ))

        self.assertEqual(200, response.code)
        token = json_body['access']['token']['id']
        tenant_id = json_body['access']['token']['tenant']['id']
        session = core.session_for_token(token)
        self.assertEqual(token, session.token)
        self.assertEqual(tenant_id, session.tenant_id)

 def test_different_username_different_token(self):
     """
     Sessions are distinct if they are requested with distinct usernames.
     """
     core = MimicCore(Clock(), [])
     a = core.session_for_username_password("a", "ignored")
     b = core.session_for_username_password("b", "ignored")
     self.assertNotEqual(a.token, b.token)

 def test_no_uuids_if_no_plugins(self):
     """
     If there are no plugins provided to :class:`MimicCore`, there are no
     uri prefixes or entries for the tenant.
     """
     core = MimicCore(Clock(), [])
     self.assertEqual(0, len(core._uuid_to_api))
     self.assertEqual([], list(core.entries_for_tenant("any_tenant", {}, "http://mimic")))

 def test_get_external_api_invalid(self):
     """
     Validate retrieving a non-existent external API which should raise an
     `IndexError` exception.
     """
     core = MimicCore(Clock(), [])
     with self.assertRaises(ServiceDoesNotExist):
         core.get_external_api(self.eeapi_name)

 def test_no_uri_prefixes_if_no_plugins(self):
     """
     If there are no plugins provided to :class:`MimicCore`, there are no
     uri prefixes or entries for the tenant.
     """
     core = MimicCore(Clock(), [])
     self.assertEqual(0, len(core.uri_prefixes))
     self.assertEqual([], list(core.entries_for_tenant('any_tenant', {},
                                                       'http://mimic')))

 def test_session_for_tenant_id(self):
     """
     MimicCore.session_for_tenant_id will return a session that can be
     retrieved by tenant_id.
     """
     clock = Clock()
     core = MimicCore(clock, [])
     session = core.session_for_username_password("someuser", "testpass")
     session2 = core.session_for_tenant_id(session.tenant_id)
     self.assertIdentical(session, session2)

 def test_remove_api_invalid(self):
     """
     Validate API removal fails when it does not find the
     api name in the listing
     """
     core = MimicCore(Clock(), [])
     with self.assertRaises(ServiceDoesNotExist):
         core.remove_external_api(
             'some-id'
         )

 def test_by_username_after_token(self):
     """
     MimicCore.session_for_username_password should retrieve the same
     session that was created by MimicCore.session_for_token.
     """
     core = MimicCore(Clock(), [])
     a = core.session_for_token("testtoken")
     b = core.session_for_username_password(a.username, "testpswd")
     c = core.session_for_api_key(a.username, "testapikey")
     self.assertIdentical(a, b)
     self.assertIdentical(a, c)

 def test_generate_username_from_tenant_id(self):
     """
     MimicCore.session_for_tenant_id will create a new session with a
     synthetic username if no such tenant ID yet exists.
     """
     clock = Clock()
     core = MimicCore(clock, [])
     session = core.session_for_tenant_id("user_specified_tenant")
     session2 = core.session_for_username_password(session.username,
                                                   "testpass")
     self.assertIdentical(session, session2)

 def test_by_token_after_username(self):
     """
     MimicCore.session_for_token should retrieve the same session that was
     created by MimicCore.session_for_username_password.
     """
     core = MimicCore(Clock(), [])
     a = core.session_for_username_password("username", "testpswd")
     b = core.session_for_token(a.token)
     self.assertIdentical(a, b)
     c = core.session_for_api_key("apiuser", "testkey")
     d = core.session_for_token(c.token)
     self.assertIdentical(c, d)

    def test_get_external_api(self):
        """
        Validate retrieving an external API.
        """
        eeapi = make_example_external_api(
            self,
            name=self.eeapi_name,
            set_enabled=True
        )

        core = MimicCore(Clock(), [eeapi])
        api_from_core = core.get_external_api(
            eeapi.uuid_key
        )
        self.assertEqual(eeapi, api_from_core)

    def test_entries_for_tenant_combined(self):
        """
        Validate that both internal and external APIs show up in the service
        catalog for a given tenant.
        """
        eeapi = make_example_external_api(
            self,
            name=self.eeapi_name,
            set_enabled=True
        )

        core = MimicCore(Clock(), [eeapi, make_example_internal_api(self)])

        prefix_map = {}
        base_uri = "http://some/random/prefix"
        catalog_entries = [
            entry
            for entry in core.entries_for_tenant(
                'some-tenant',
                prefix_map,
                base_uri
            )
        ]

        self.assertEqual(len(core._uuid_to_api_internal), 1)
        self.assertEqual(len(core._uuid_to_api_external), 1)
        self.assertEqual(len(catalog_entries), 2)

        found_internal = False
        found_external = False

        for catalog_entry in catalog_entries:
            if catalog_entry.name == eeapi.name_key:
                found_external = True
                self.assertEqual(catalog_entry.type, eeapi.type_key)
                self.assertEqual(catalog_entry.name, eeapi.name_key)
                self.assertEqual(catalog_entry.tenant_id, "some-tenant")
                self.assertEqual(len(catalog_entry.endpoints), 1)

            elif catalog_entry.name == "serviceName":
                found_internal = True
                self.assertEqual(catalog_entry.type, "serviceType")
                self.assertEqual(catalog_entry.name, "serviceName")
                self.assertEqual(catalog_entry.tenant_id, "some-tenant")
                self.assertEqual(len(catalog_entry.endpoints), 1)

        self.assertTrue(found_internal)
        self.assertTrue(found_external)

    def test_session_created_for_token(self):
        """
        A session is created for the token provided
        """
        core = MimicCore(Clock(), [])
        root = MimicRoot(core).app.resource()

        token = '1234567890'

        request(
            self, root, "GET",
            "/identity/v2.0/tokens/{0}/endpoints".format(token)
        )

        session = core.session_for_token(token)
        self.assertEqual(token, session.token)

 def test_from_plugin_includes_all_plugins(self):
     """
     Using the :func:`MimicRoot.fromPlugin` creator for a
     :class:`MimicCore`, the nova and loadbalancer plugins are included.
     """
     core = MimicCore.fromPlugins(Clock())
     plugin_apis = set((
         glance_plugin.glance,
         loadbalancer_plugin.loadbalancer,
         loadbalancer_plugin.loadbalancer_control,
         maas_plugin.maas,
         maas_plugin.maas_control,
         nova_plugin.nova,
         nova_plugin.nova_control_api,
         queue_plugin.queue,
         rackconnect_v3_plugin.rackconnect,
         swift_plugin.swift,
         cloudfeeds_plugin.cloudfeeds,
         cloudfeeds_plugin.cloudfeeds_control,
     ))
     self.assertEqual(
         plugin_apis,
         set(core._uuid_to_api.values()))
     self.assertEqual(
         len(plugin_apis),
         len(list(core.entries_for_tenant('any_tenant', {},
                                          'http://mimic'))))

    def test_load_domain_plugin_includes_all_domain_plugins(self):
        """
        Using the :func:`MimicRoot.fromPlugin` creator for a
        :class:`MimicCore`, domain mocks implementing `class`:`IAPIDomainMock`
        are included.
        """
        self.root = FilePath(self.mktemp())
        self.root.createDirectory()
        plugin = b"""from mimic.test.dummy import ExampleDomainAPI
dummy_domain_plugin = ExampleDomainAPI()
"""
        self.root.child('fake_plugin.py').setContent(plugin)

        import mimic.plugins
        mimic.plugins.__path__.append(self.root.path)
        from mimic.plugins import fake_plugin

        def cleanup():
            sys.modules.pop("mimic.plugins.fake_plugin")
            del mimic.plugins.fake_plugin
        self.addCleanup(cleanup)

        core = MimicCore.fromPlugins(Clock())
        self.assertIn(
            fake_plugin.dummy_domain_plugin,
            core.domains
        )

 def test_remove_api_with_endpoints(self):
     """
     Validate an API cannot be removed if it still has
     endpoints assigned to it
     """
     eeapi = make_example_external_api(
         self,
         name=self.eeapi_name,
         set_enabled=True
     )
     self.assertIsNotNone(eeapi)
     core = MimicCore(Clock(), [eeapi])
     with self.assertRaises(ServiceHasTemplates):
         core.remove_external_api(
             eeapi.uuid_key
         )

 def test_from_plugin_includes_all_plugins(self):
     """
     Using the :func:`MimicRoot.fromPlugin` creator for a
     :class:`MimicCore`, the nova and loadbalancer plugins are included.
     """
     core = MimicCore.fromPlugins(Clock())
     plugin_apis = set((
         glance_plugin.glance,
         heat_plugin.heat,
         loadbalancer_plugin.loadbalancer,
         loadbalancer_plugin.loadbalancer_control,
         maas_plugin.maas,
         maas_plugin.maas_control,
         nova_plugin.nova,
         nova_plugin.nova_control_api,
         queue_plugin.queue,
         rackconnect_v3_plugin.rackconnect,
         swift_plugin.swift,
         cloudfeeds_plugin.cloudfeeds,
         cloudfeeds_plugin.cloudfeeds_control,
         neutron_plugin.neutron,
         dns_plugin.dns,
         cinder_plugin.cinder
     ))
     # all plugins should be on the internal listing
     self.assertEqual(
         plugin_apis,
         set(core._uuid_to_api_internal.values()))
     # the external listing should still be empty
     self.assertEqual(
         set([]),
         set(core._uuid_to_api_external.values()))

    def test_entries_for_tenant_external_with_tenantid_replacement(self):
        """
        Validate that the external API shows up in the service catalog for a
        given tenant and the tenant id is in the URL.
        """
        eeapi = make_example_external_api(
            self,
            name=self.eeapi_name,
            set_enabled=True
        )

        tenant_id = 'some-tenant-other'

        ept_internal_url = "http://internal.url/v1/" + tenant_id
        ept_public_url = "http://public.url/v1/" + tenant_id
        for ept in eeapi.endpoint_templates.values():
            ept.internal_url = "http://internal.url/v1/%tenant_id%"
            ept.public_url = "http://public.url/v1/%tenant_id%"

        core = MimicCore(Clock(), [eeapi])

        prefix_map = {}
        base_uri = "http://some/random/prefix"
        catalog_entries = [
            entry
            for entry in core.entries_for_tenant(
                tenant_id,
                prefix_map,
                base_uri
            )
        ]

        self.assertEqual(len(core._uuid_to_api_internal), 0)
        self.assertEqual(len(core._uuid_to_api_external), 1)
        self.assertEqual(len(catalog_entries), 1)
        self.assertEqual(catalog_entries[0].type, eeapi.type_key)
        self.assertEqual(catalog_entries[0].name, eeapi.name_key)
        self.assertEqual(catalog_entries[0].tenant_id, tenant_id)
        self.assertEqual(len(catalog_entries[0].endpoints), 1)
        self.assertEqual(
            catalog_entries[0].endpoints[0].internal_url,
            ept_internal_url
        )
        self.assertEqual(
            catalog_entries[0].endpoints[0].complete_url,
            ept_public_url
        )