Python helpers.json_request函数代码示例

    def test_check_domains(self):
        """
        ``GET/service/{service_id}/version/{version_id}/domain/check_all`` against
        Fastly mock returns an array with the status of all domain DNS records
        for a service version.
        """
        uri = self.uri + '/service/{0}/version/{1}/domain' \
            '?name=llamallama&comment=redpajama'.format(
                self.service_id, self.version_id)

        (response, json_body) = self.successResultOf(json_request(
            self, self.root, b"POST", uri))

        uri = self.uri + '/service/{0}/version/{1}/domain/check_all' \
            '?name=llamallama&comment=redpajama'.format(
                self.service_id, self.version_id)

        (response, json_body) = self.successResultOf(json_request(
            self, self.root, b"GET", uri))
        domain_details = self.fastly_response.check_domains(
            service_id=self.service_id,
            service_version=self.version_id)

        self.assertEqual(200, response.code)
        self.assertEqual(sorted(json_body), sorted(domain_details))

 def test_check_existing_username_is_true(self):
     """
     Checking a username that exists gets a true response.
     """
     (resp, _) = self.successResultOf(json_request(
         self, self.root, b"POST", '{0}/yo/'.format(self.uri),
         json.dumps({'username': 'TESTUSER4',
                     'api_key': 'A1234567890'}).encode("utf-8")))
     self.assertEquals(resp.code, 200)
     (resp, data) = self.successResultOf(json_request(
         self, self.root, b"GET", '{0}/check_username/?username=TESTUSER4'.format(self.uri)))
     self.assertEquals(resp.code, 200)
     self.assertEquals(data['exists'], True)

    def test_create_then_get_node_with_mimimum_attributes(self):
        """
        Test create node then get the node and verify attributes
        """
        (response, content) = self.successResultOf(json_request(
            self, self.root, "POST", self.url, body=json.dumps({})))
        self.assertEqual(response.code, 201)
        node_id = str(content['uuid'])
        self.assertFalse(content['properties']['memory_mb'])

        # get node
        (response, get_content) = self.successResultOf(json_request(
            self, self.root, "GET", self.url + '/' + node_id))
        self.assertEqual(200, response.code)
        self.assertEqual(content, get_content)

    def test_invalid_template_id(self):
        """
        PUT requires the endpoint template id to match an existing endpoint
        template, otherwise results in 404.
        """
        self.core.add_api(self.eeapi)
        id_key = get_template_id(self, self.eeapi)
        self.eeapi.remove_template(id_key)

        data = {
            'id': id_key,
            'name': self.eeapi_name,
            'type': self.eeapi.type_key,
            'region': 'some-region'
        }

        self.headers[b'serviceid'] = [self.eeapi.uuid_key.encode('utf8')]

        (response, json_body) = self.successResultOf(
            json_request(self, self.root, self.verb,
                         self.uri,
                         body=data,
                         headers=self.headers))

        self.assertEqual(response.code, 404)
        self.assertEqual(json_body['itemNotFound']['code'], 404)
        self.assertEqual(
            json_body['itemNotFound']['message'],
            "Unable to update non-existent template. Template must "
            "first be added before it can be updated.",
        )

    def test_test_alarm_clearing_response(self):
        """
        Sending HTTP DELETE to the entity's test-alarm response
        causes the response to be cleared and not returned later.
        """
        resp = self.successResultOf(
            request(self, self.root, "PUT",
                    '{0}/entities/{1}/alarms/test_response'.format(
                        self.ctl_uri, self.entity_id),
                    json.dumps([{'state': 'OK',
                                 'status': 'test-alarm working OK'}])))
        self.assertEquals(resp.code, 204)

        resp = self.successResultOf(request(self, self.root, "DELETE",
                                            '{0}/entities/{1}/alarms/test_response'.format(
                                                self.ctl_uri, self.entity_id)))
        self.assertEquals(resp.code, 204)

        (resp, data) = self.successResultOf(
            json_request(self, self.root, "POST",
                         self.uri + '/entities/' + self.entity_id + '/test-alarm',
                         json.dumps({'criteria': 'return new AlarmStatus(OK);',
                                     'check_data': [{}]})))
        self.assertEquals(resp.code, 200)
        self.assertEquals(1, len(data))
        self.assertNotEquals('test-alarm working OK', data[0]['status'])

    def test_new_endpoint_template_wrong_service_type(self):
        """
        PUT requires that the service matches, otherwise results in 409.
        """
        self.core.add_api(self.eeapi)

        data = {
            'id': self.ept_template_id,
            'name': self.eeapi_name,
            'type': 'some-type',
            'region': 'some-region'
        }
        (response, json_body) = self.successResultOf(
            json_request(self, self.root, self.verb,
                         self.uri,
                         body=data,
                         headers=self.headers))

        self.assertEqual(response.code, 409)
        self.assertEqual(json_body['conflict']['code'], 409)
        self.assertEqual(
            json_body['conflict']['message'],
            "Endpoint already exists and service id or service type does not "
            "match."
        )

    def test_json_body_missing_required_field_name(self, remove_field):
        """
        PUT - required fields must be present otherwise 400 is generated.
        """
        data = {
            'id': self.ept_template_id,
            'name': 'some-name',
            'type': 'some-type',
            'region': 'some-region'
        }
        del data[remove_field]

        (response, json_body) = self.successResultOf(
            json_request(self, self.root, self.verb,
                         self.uri,
                         body=data,
                         headers=self.headers))

        self.assertEqual(response.code, 400)
        self.assertEqual(json_body['badRequest']['code'], 400)
        self.assertTrue(
            json_body['badRequest']['message'].startswith(
                "JSON body does not contain the required parameters:"
            )
        )

 def test_send_yo_to_same_username_gets_same_userid(self):
     """
     Sending a Yo to the same username twice causes the same user ID
     to come back in the response.
     """
     (resp, data1) = self.successResultOf(json_request(
         self, self.root, b"POST", '{0}/yo/'.format(self.uri),
         json.dumps({'username': 'TESTUSER2',
                     'api_key': 'A1234567890'}).encode("utf-8")))
     self.assertEquals(resp.code, 200)
     (resp, data2) = self.successResultOf(json_request(
         self, self.root, b"POST", '{0}/yo/'.format(self.uri),
         json.dumps({'username': 'TESTUSER2',
                     'api_key': 'A1234567890'}).encode("utf-8")))
     self.assertEquals(resp.code, 200)
     self.assertEquals(data1['recipient']['user_id'], data2['recipient']['user_id'])

    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": "demoauthor",
                        "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 register_behavior(test_case, root, uri, behavior_name, parameters,
                      criteria):
    """
    Register a particular behavior.

    :param test_case: the test case with which to make assertions
    :param root: A mimic root API object
    :param str uri: The uri fo the behavior resource to register.
    :param str behavior_name: The name of the behavior
    :param dict parameters: A dictionary of parameters to pass to the behavior
    :param list criteria: The criteria for which this behavior should be
        applied.

    :return: The behavior ID of the registered behavior.
    """
    behavior_json = {"name": behavior_name,
                     "parameters": parameters,
                     "criteria": criteria}
    response, body = test_case.successResultOf(json_request(
        test_case, root, "POST", uri, json.dumps(behavior_json)))

    test_case.assertEqual(response.code, 201)
    behavior_id = body.get("id")
    test_case.assertIsInstance(behavior_id, string_types)
    test_case.assertEqual(UUID(behavior_id).version, 4)
    return behavior_id

    def test_multiple_external_apis(self):
        """
        GET can retrieve numerous External APIs that have External API Templates.
        """
        api_list = [
            make_example_external_api(
                self,
                name=self.eeapi_name + text_type(uuid.uuid4()),
                service_type='service-' + text_type(uuid.uuid4())
            )
            for ignored in range(10)
        ]
        #  eeapi needs to be the first in the list
        api_list.insert(0, self.eeapi)
        for api in api_list:
            self.core.add_api(api)

        self.assertEqual(len(self.core._uuid_to_api_external),
                         len(api_list))

        (response, json_body) = self.successResultOf(
            json_request(self, self.root, self.verb,
                         self.uri,
                         headers=self.headers))

        self.assertEqual(response.code, 200)

        self.assertEqual(len(json_body['OS-KSCATALOG']),
                         len(api_list))
        self.assertEqual(
            len(json_body['OS-KSCATALOG:endpointsTemplates_links']),
            0)

    def test_json_body_missing_required_field(self, remove_field):
        """
        POST requires 'name' field otherwise 400 is generated.
        """
        # normal JSON body
        data = {
            'type': 'some-type',
            'name': 'some-name'
        }
        # remove a portion of the body per the DDT data
        del data[remove_field]

        # POST the resulting JSON to the REST API
        (response, json_body) = self.successResultOf(
            json_request(self, self.root, self.verb,
                         self.uri,
                         body=data,
                         headers=self.headers))

        # API should return 400 since a required field is missing
        self.assertEqual(response.code, 400)
        self.assertEqual(json_body['badRequest']['code'], 400)
        self.assertEqual(json_body['badRequest']['message'],
                         "Invalid Content. 'name' and 'type' fields are "
                         "required.")

    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": "demoauthor",
                        "password": "theUsersPassword"
                    }
                }
            }
        ))

        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 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.sessions.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.sessions.session_for_token(token)
        self.assertEqual(token, session.token)
        self.assertEqual(tenant_id, session.tenant_id)