def setUp(self): """ Initialize core and root """ self.core = MimicCore(Clock(), []) self.root = MimicRoot(self.core).app.resource() self.node_details_attributes = [ "instance_uuid", "target_power_state", "chassis_uuid", "properties", "uuid", "driver_info", "target_provision_state", "last_error", "console_enabled", "extra", "driver", "links", "maintenance_reason", "updated_at", "provision_updated_at", "maintenance", "provision_state", "reservation", "created_at", "power_state", "instance_info", "ports", "name", "driver_internal_info", "inspection_finished_at", "inspection_started_at", "clean_step" ] self.url = "/ironic/v1/nodes" self.create_request = { "chassis_uuid": str(uuid4()), "driver": "agent_ipmitool", "driver_info": { "ipmi_username": "******", "ipmi_address": "127.0.0.0", "ipmi_password": "******" }, "name": "test_node", "properties": { "cpus": "1", "local_gb": "10", "memory_mb": "1024" } }
def setUp(self): self.core = MimicCore(Clock(), []) self.root = MimicRoot(self.core).app.resource() self.uri = "/identity/v2.0/services" self.eeapi_name = u"externalServiceName" self.headers = {b'X-Auth-Token': [b'ABCDEF987654321']} self.verb = b"GET"
def test_tick(self): """ ``/mimic/v1.1/tick`` (handled by :func:`MimicRoot.advance_time`) advances the clock associated with the service. """ clock = Clock() def do(): do.done = True do.done = False clock.callLater(3.5, do) core = MimicCore(clock, []) root = MimicRoot(core, clock).app.resource() self.assertEqual(do.done, False) jreq = json_request( self, root, "POST", "/mimic/v1.1/tick", body={"amount": 3.6} ) [response, json_content] = self.successResultOf(jreq) self.assertEqual(response.code, 200) expected = { 'advanced': 3.6, 'now': '1970-01-01T00:00:03.600000Z', } self.assertEqual(json_content, expected) self.assertEqual(do.done, True)
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": "******", "password": "******" } } })) self.assertEqual(200, response.code) token = json_body['access']['token']['id'] tenant_id = json_body['access']['token']['tenant']['id'] session = core.sessions.session_for_token(token) self.assertEqual(token, session.token) self.assertEqual(tenant_id, session.tenant_id)
def setUp(self): """ Initialize core and root """ self.core = MimicCore(Clock(), []) self.root = MimicRoot(self.core).app.resource() self.url = "/valkyrie/v2.0"
def createSwiftService(self, rackspace_flavor=True): """ Set up to create the requests """ self.swift_mock = SwiftMock(rackspace_flavor) self.core = MimicCore(Clock(), [self.swift_mock]) self.root = MimicRoot(self.core).app.resource() self.response = request( self, self.root, b"POST", b"/identity/v2.0/tokens", dumps({ "auth": { "passwordCredentials": { "username": "******", "password": "******", }, # TODO: should this really be 'tenantId'? "tenantName": "fun_tenant", } }).encode("utf-8")) self.auth_response = self.successResultOf(self.response) text_body = self.successResultOf(treq.content( self.auth_response)).decode("utf-8") self.json_body = loads(text_body)
def test_get_token_and_catalog_for_token_credentials(self): """ The response returned should include the credentials that were supplied during authentication """ core = MimicCore(Clock(), [ExampleAPI()]) root = MimicRoot(core).app.resource() (response, json_body) = self.successResultOf( json_request( self, root, "POST", "/identity/v2.0/tokens", { "auth": { "tenantId": "12345", "token": { "id": "iuyiuyiuy-uyiuyiuy-1987878" } } })) self.assertEqual(response.code, 200) tenant_id = json_body["access"]["token"]["tenant"]["id"] self.assertEqual(tenant_id, "12345") tenant_name = json_body["access"]["token"]["tenant"]["name"] self.assertEqual(tenant_name, tenant_id) user_name = json_body["access"]["user"]["name"] self.assertTrue(user_name)
def __init__(self, test_case, apis): """ Initialize a mimic core and the specified :obj:`mimic.imimic.IAPIMock`s :param apis: A list of :obj:`mimic.imimic.IAPIMock` objects to be initialized """ self.test_case = test_case self.clock = Clock() self.core = MimicCore(self.clock, apis) self.root = MimicRoot(self.core).app.resource() # Pass in arbitrary username and password self.auth = TenantAuthentication(test_case, self.root, "test1", "test1password") # map some attributes and methods self.service_catalog_json = self.auth.service_catalog_json self.get_service_endpoint = self.auth.get_service_endpoint # Tenant ID of test tenant authenticated against mimic identity self.tenant_id = self.auth.service_catalog_json["access"]["token"][ "tenant"]["id"] service_name = apis[0].catalog_entries(self.tenant_id)[0].name self.uri = self.get_service_endpoint(service_name)
def test_auth_accepts_tenant_id(self): """ If "tenantId" 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": "******", "password": "******" }, "tenantId": "turtlepower" } })) self.assertEqual(200, response.code) self.assertEqual("turtlepower", json_body['access']['token']['tenant']['id']) token = json_body['access']['token']['id'] session = core.sessions.session_for_token(token) self.assertEqual(token, session.token) self.assertEqual("turtlepower", session.tenant_id)
def test_api_service_endpoints_are_not_duplicated(self): """ The service catalog should not duplicate endpoints for an entry/endpoints """ regions_and_versions_list = [("ORD", "v1"), ("DFW", "v1"), ("DFW", "v2"), ("IAD", "v3")] core = MimicCore( Clock(), [ExampleAPI(regions_and_versions=regions_and_versions_list)]) root = MimicRoot(core).app.resource() (response, json_body) = self.successResultOf( json_request( self, root, "POST", "/identity/v2.0/tokens", { "auth": { "passwordCredentials": { "username": "******", "password": "******" } } })) self.assertEqual(response.code, 200) service_catalog = json_body["access"]["serviceCatalog"] self.assertEqual(len(service_catalog), 1) endpoints_list = service_catalog[0]["endpoints"] self.assertEqual(len(endpoints_list), 4)
def setUp(self): """ Create a check """ core = MimicCore(Clock(), []) self.root = MimicRoot(core).app.resource() self.create_check = { "check": { "attributes": { "name": "name", "module": "module", "target": "target", "period": "period", "timeout": "timeout", "filterset": "filterset" } } } self.create_check_xml_payload = xmltodict.unparse( self.create_check).encode("utf-8") self.check_id = uuid.uuid4() url = "noit/checks/set/{0}".format(self.check_id) (self.response, response_body) = self.successResultOf( request_with_content(self, self.root, "PUT", url, body=self.create_check_xml_payload)) self.create_json_response = xmltodict.parse(response_body)
def test_response_has_same_roles_despite_number_of_auths(self): """ The JSON response for authenticate has only one `identity:user-admin` role, no matter how many times the user authenticates. """ core = MimicCore(Clock(), []) root = MimicRoot(core).app.resource() creds = { "auth": { "passwordCredentials": { "username": "******", "password": "******" } } } self.successResultOf( json_request(self, root, "POST", "/identity/v2.0/tokens", creds)) self.successResultOf( json_request(self, root, "POST", "/identity/v2.0/tokens", creds)) (response, json_body) = self.successResultOf( json_request(self, root, "POST", "/identity/v2.0/tokens", creds)) self.assertEqual(200, response.code) self.assertEqual(json_body['access']['user']['roles'], HARD_CODED_ROLES)
def setUp(self): """ Create a :obj:`MimicCore` with :obj:`QueueApi` as the only plugin, and create a queue """ self.clock = Clock() self.core = MimicCore(self.clock, [QueueApi()]) self.root = MimicRoot(self.core).app.resource() self.response = request( self, self.root, b"POST", "/identity/v2.0/tokens", json.dumps({ "auth": { "passwordCredentials": { "username": "******", "password": "******", }, } }).encode("utf-8")) self.auth_response = self.successResultOf(self.response) self.json_body = self.successResultOf( treq.json_content(self.auth_response)) self.uri = self.json_body['access']['serviceCatalog'][0]['endpoints'][ 0]['publicURL'] self.queue_name = "test_queue" self.create_queue = request(self, self.root, b"PUT", self.uri + '/queues/' + self.queue_name) self.create_queue_response = self.successResultOf(self.create_queue)
def test_get_token_and_catalog_for_api_credentials(self): """ The response returned should include the credentials that were supplied during authentication """ core = MimicCore(Clock(), [ExampleAPI()]) root = MimicRoot(core).app.resource() (response, json_body) = self.successResultOf( json_request( self, root, "POST", "/identity/v2.0/tokens", { "auth": { "RAX-KSKEY:apiKeyCredentials": { "username": "******", "apiKey": "jhgjhghg-nhghghgh-12222" }, "tenantName": "12345" } })) self.assertEqual(response.code, 200) tenant_id = json_body["access"]["token"]["tenant"]["id"] self.assertEqual(tenant_id, "12345") tenant_name = json_body["access"]["token"]["tenant"]["name"] self.assertEqual(tenant_name, tenant_id) user_name = json_body["access"]["user"]["name"] self.assertEqual(user_name, "demoauthor")
def test_response_service_catalog_has_base_uri(self): """ The JSON response's service catalog whose endpoints all begin with the same base URI as the request. """ core = MimicCore(Clock(), [ExampleAPI()]) root = MimicRoot(core).app.resource() (response, json_body) = self.successResultOf( json_request( self, root, "POST", "http://mybase/identity/v2.0/tokens", { "auth": { "passwordCredentials": { "username": "******", "password": "******" } } })) self.assertEqual(200, response.code) services = json_body['access']['serviceCatalog'] self.assertEqual(1, len(services)) urls = [endpoint['publicURL'] for endpoint in services[0]['endpoints']] self.assertEqual(1, len(urls)) self.assertTrue( urls[0].startswith('http://mybase/'), '{0} does not start with "http://mybase"'.format(urls[0]))
def setUp(self): """ Initialize core and root """ self.core = MimicCore(Clock(), []) self.root = MimicRoot(self.core).app.resource() self.uri = "/glance/v2/images" self.create_request = {"name": "OnMetal - MIMIC", "distro": "linux"}
def setUp(self): self.core = MimicCore(Clock(), []) self.root = MimicRoot(self.core).app.resource() self.uri = "/identity/v2.0/OS-KSCATALOG/endpointTemplates" self.eeapi_name = u"externalServiceName" self.eeapi = make_example_external_api(self, name=self.eeapi_name, set_enabled=True) self.headers = {b'X-Auth-Token': [b'ABCDEF987654321']} self.verb = b"GET"
def test_send_grid(self): """ ``/sendgrid/mail.send.json`` returns response code 200. """ core = MimicCore(Clock(), []) root = MimicRoot(core).app.resource() response = self.successResultOf( request(self, root, b"POST", "/sendgrid/mail.send.json")) self.assertEqual(200, response.code)
def test_fastly(self): """ The /fastly pointing to the fastly endpoint """ core = MimicCore(Clock(), []) root = MimicRoot(core).app.resource() (response, json_content) = self.successResultOf( json_request(self, root, b'GET', '/fastly')) self.assertEqual(200, response.code) self.assertEqual(json_content, {'status': 'ok'})
def test_authentication_request_with_no_body_causes_http_bad_request(self): """ The response for empty body request is bad_request. """ core = MimicCore(Clock(), []) root = MimicRoot(core).app.resource() (response, json_body) = self.successResultOf( json_request(self, root, "POST", "/identity/v2.0/tokens", "")) self.assertEqual(400, response.code)
def setUp(self): self.tenant_id = 'some_tenant' self.core = MimicCore(Clock(), []) self.root = MimicRoot(self.core).app.resource() self.uri = ("/identity/v2.0/tenants/" + self.tenant_id + "/OS-KSCATALOG/endpoints") self.eeapi_name = u"externalServiceName" self.eeapi = make_example_external_api(self, name=self.eeapi_name, set_enabled=False) self.headers = {b'X-Auth-Token': [b'ABCDEF987654321']} self.verb = b"POST"
def setUp(self): self.tenant_id = 'some_tenant' self.core = MimicCore(Clock(), []) self.root = MimicRoot(self.core).app.resource() self.eeapi_name = u"externalServiceName" self.eeapi = make_example_external_api(self, name=self.eeapi_name) self.template_id = get_template_id(self, self.eeapi) self.assertIsNotNone(self.template_id) self.uri = ("/identity/v2.0/tenants/" + self.tenant_id + "/OS-KSCATALOG/endpoints/" + self.template_id) self.headers = {b'X-Auth-Token': [b'ABCDEF987654321']} self.verb = b"DELETE"
def test_response_for_get_username(self): """ Test to verify :func: `get_username`. """ core = MimicCore(Clock(), [ExampleAPI()]) root = MimicRoot(core).app.resource() (response, json_body) = self.successResultOf( json_request(self, root, "GET", "http://mybase/identity/v1.1/mosso/123456")) self.assertEqual(301, response.code) self.assertTrue(json_body['user']['id'])
def test_domain_mock(self): """ A GET on ``http://mimic-host.example.com:port/domain`` should return the list of all the domains; empty, if no plugins are registered. """ core = MimicCore(Clock(), []) root = MimicRoot(core).app.resource() response = self.successResultOf(request( self, root, b"GET", "http://mybase/domain")) self.assertEqual(200, response.code)
def make_request_to_site(self): """ Make a request and return the response. """ core = MimicCore(Clock(), [ExampleAPI('response!')]) root = MimicRoot(core).app.resource() # get the region and service id registered for the example API (region, service_id) = one_api(self, core) url = "/mimicking/{0}/{1}".format(service_id, region) response = self.successResultOf( request(self, root, "GET", url, headers={"one": ["two"]})) return (response, url)
def __init__(self, test_case, domains): """ Initialize a mimic core and the specified :obj:`mimic.imimic.IAPIMock`s :param domains: A list of :obj:`mimic.imimic.IAPIDomainMock` objects to be initialized """ self.test_case = test_case self.clock = Clock() self.core = MimicCore(self.clock, [], domains=domains) self.root = MimicRoot(self.core).app.resource() self.uri = '/domain/{0}'.format(domains[0].domain())
def test_authentication_request_with_invalid_body_causes_http_bad_request( self): """ The response for not JSON body request is bad_request. """ core = MimicCore(Clock(), []) root = MimicRoot(core).app.resource() response = self.successResultOf( request(self, root, "POST", "/identity/v2.0/tokens", "{ bad request: }")) self.assertEqual(400, response.code)
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.sessions.session_for_token(token) self.assertEqual(token, session.token)
def startMimic(): """ Setup the mimic application using steps similar to :obj:`mimic.tap.makeService' and start listening for requests. """ clock = Clock() core = MimicCore.fromPlugins(clock) root = MimicRoot(core, clock) site = Site(root.app.resource()) site.displayTracebacks = False endpoint = serverFromString(reactor, b"tcp:{0}:interface=127.0.0.1".format(_PORT)) endpoint.listen(site)
def test_domain_mock_with_an_example_mock(self): """ A GET on the ``http://mimic-host.example.com:port/domain`` should return the list of all the domains, enumerating all registered plugins. """ example_domain_api = ExampleDomainAPI() core = MimicCore(Clock(), [], [example_domain_api]) root = MimicRoot(core).app.resource() response, content = self.successResultOf(json_request( self, root, b"GET", "http://mybase/domain")) self.assertEqual(200, response.code) self.assertEqual(content, [u'api.example.com'])