Python Response.status_code方法代码示例

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def test_get_response_streaming_ng(self):
        http_response = Response()
        http_response.headers = {
            'content-type': 'application/xml',
            'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
            'server': 'AmazonS3',
            'transfer-encoding': 'chunked',
            'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
            'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
        http_response.raw = six.BytesIO(XMLBODY1)
        http_response.status_code = 403
        http_response.reason = 'Forbidden'

        session = botocore.session.get_session()
        s3 = session.get_service('s3')
        operation = s3.get_operation('GetObject') # streaming operation

        self.assertEqual(
            response.get_response(session, operation, http_response)[1], 
            {u'Body': None,
              'Errors': [{'HostId': 'AAAAAAAAAAAAAAAAAAA',
                          'Message': 'Access Denied',
                          'Code': 'AccessDenied',
                          'RequestId': 'XXXXXXXXXXXXXXXX'}],
              'ResponseMetadata': {},
             u'Metadata': {}}
            )

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def test_get_response_streaming_ng(self):
        http_response = Response()
        http_response.headers = {
            'content-type': 'application/xml',
            'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
            'server': 'AmazonS3',
            'transfer-encoding': 'chunked',
            'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
            'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
        http_response.raw = six.BytesIO(XMLBODY1)
        http_response.status_code = 403
        http_response.reason = 'Forbidden'

        session = botocore.session.get_session()
        service_model = session.get_service_model('s3')
        operation_model = service_model.operation_model('GetObject')

        self.assertEqual(
            response.get_response(operation_model, http_response)[1],
            {'Error': {'Message': 'Access Denied',
                       'Code': 'AccessDenied',},
             'ResponseMetadata': {'HostId': 'AAAAAAAAAAAAAAAAAAA',
                                  'RequestId': 'XXXXXXXXXXXXXXXX',
                                  'HTTPStatusCode': 403},
             }
        )

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def test_get_response_nonstreaming_ok(self):
        http_response = Response()
        http_response.headers = {
            'content-type': 'application/xml',
            'date': 'Sun, 09 Mar 2014 02:55:43 GMT',
            'server': 'AmazonS3',
            'transfer-encoding': 'chunked',
            'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
            'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
        http_response.raw = six.BytesIO(XMLBODY1)
        http_response.status_code = 403
        http_response.reason = 'Forbidden'
        http_response.request = Request()

        session = botocore.session.get_session()
        service_model = session.get_service_model('s3')
        operation_model = service_model.operation_model('ListObjects')

        self.assert_response_with_subset_metadata(
            response.get_response(operation_model, http_response)[1],
            {
                'ResponseMetadata': {
                    'RequestId': 'XXXXXXXXXXXXXXXX',
                    'HostId': 'AAAAAAAAAAAAAAAAAAA',
                    'HTTPStatusCode': 403
                },
                'Error': {
                    'Message': 'Access Denied',
                    'Code': 'AccessDenied'
                }
            })

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def test_get_response_nonstreaming_ng(self):
        http_response = Response()
        http_response.headers = {
            'content-type': 'application/xml',
            'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
            'server': 'AmazonS3',
            'transfer-encoding': 'chunked',
            'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
            'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
        http_response.raw = six.BytesIO(XMLBODY2)
        http_response.status_code = 200
        http_response.reason = 'ok'
        http_response.request = Request()

        session = botocore.session.get_session()
        s3 = session.get_service('s3')
        operation = s3.get_operation('ListObjects') # non-streaming operation

        self.assertEqual(
            response.get_response(session, operation, http_response)[1], 
            {u'CommonPrefixes': [],
             u'Contents': [{u'ETag': '"00000000000000000000000000000000"',
                            u'Key': 'test.png',
                            u'LastModified': '2014-03-01T17:06:40.000Z',
                            u'Owner': {u'DisplayName': 'dummy',
                                       u'ID': 'AAAAAAAAAAAAAAAAAAA'},
                            u'Size': 6702,
                            u'StorageClass': 'STANDARD'}],
             u'IsTruncated': False,
             u'Marker': None,
             u'MaxKeys': 1000,
             u'Name': 'mybucket',
             u'Prefix': None,
             'ResponseMetadata': {}}
            )

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def test_get_response_nonstreaming_ok(self):
        http_response = Response()
        http_response.headers = {
            'content-type': 'application/xml',
            'date': 'Sun, 09 Mar 2014 02:55:43 GMT',
            'server': 'AmazonS3',
            'transfer-encoding': 'chunked',
            'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
            'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
        http_response.raw = six.BytesIO(XMLBODY1)
        http_response.status_code = 403
        http_response.reason = 'Forbidden'
        http_response.request = Request()

        session = botocore.session.get_session()
        s3 = session.get_service('s3')
        operation = s3.get_operation('ListObjects') # non-streaming operation

        self.assertEqual(
            response.get_response(session, operation, http_response)[1], 
            { 'ResponseMetadata': {},
              'Errors': [{'HostId': 'AAAAAAAAAAAAAAAAAAA',
                          'Message': 'Access Denied',
                          'Code': 'AccessDenied',
                          'RequestId': 'XXXXXXXXXXXXXXXX'}],
              'ResponseMetadata': {},
              u'CommonPrefixes': [],
              u'Contents': [],
              }
            )

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def build_response(self, request):
        status_code = self.resp['status_code']
        headers = self.resp['headers']
        body = self.resp['body']

        response = Response()
        response.status_code = status_code

        if 'content-type' not in headers:
            headers['content-type'] = 'text/xml'
        if 'content-length' not in headers:
            headers['content-length'] = len(body)

        response.raw = HTTPResponse(
            body=io.BytesIO(body),
            headers=headers,
            status=status_code,
            reason=CODE_TO_REASON[status_code],
            preload_content=False,
            decode_content=False
        )
        response.reason = response.raw.reason

        # From the request
        response.url = request.url
        response.request = request

        response.connection = self

        return response

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def add_client_error(self, method, service_error_code='',
                         service_message='', http_status_code=400,
                         service_error_meta=None, expected_params=None):
        """
        Adds a ``ClientError`` to the response queue.

        :param method: The name of the service method to return the error on.
        :type method: str

        :param service_error_code: The service error code to return,
                                   e.g. ``NoSuchBucket``
        :type service_error_code: str

        :param service_message: The service message to return, e.g.
                        'The specified bucket does not exist.'
        :type service_message: str

        :param http_status_code: The HTTP status code to return, e.g. 404, etc
        :type http_status_code: int

        :param service_error_meta: Additional keys to be added to the
            service Error
        :type service_error_meta: dict

        :param expected_params: A dictionary of the expected parameters to
            be called for the provided service response. The parameters match
            the names of keyword arguments passed to that client call. If
            any of the parameters differ a ``StubResponseError`` is thrown.
            You can use stub.ANY to indicate a particular parameter to ignore
            in validation. stub.ANY is only valid for top level params.
        """
        http_response = Response()
        http_response.status_code = http_status_code

        # We don't look to the model to build this because the caller would
        # need to know the details of what the HTTP body would need to
        # look like.
        parsed_response = {
            'ResponseMetadata': {'HTTPStatusCode': http_status_code},
            'Error': {
                'Message': service_message,
                'Code': service_error_code
            }
        }

        if service_error_meta is not None:
            parsed_response['Error'].update(service_error_meta)

        operation_name = self.client.meta.method_to_api_mapping.get(method)
        # Note that we do not allow for expected_params while
        # adding errors into the queue yet.
        response = {
            'operation_name': operation_name,
            'response': (http_response, parsed_response),
            'expected_params': expected_params,
        }
        self._queue.append(response)

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def add_client_error(self, method, service_error_code='',
                         service_message='', http_status_code=400,
                         service_error_meta=None):
        """
        Adds a ``ClientError`` to the response queue.

        :param method: The name of the service method to return the error on.
        :type method: str

        :param service_error_code: The service error code to return,
                                   e.g. ``NoSuchBucket``
        :type service_error_code: str

        :param service_message: The service message to return, e.g.
                        'The specified bucket does not exist.'
        :type service_message: str

        :param http_status_code: The HTTP status code to return, e.g. 404, etc
        :type http_status_code: int

        :param service_error_meta: Additional keys to be added to the
            service Error
        :type service_error_meta: dict
        """
        http_response = Response()
        http_response.status_code = http_status_code

        # We don't look to the model to build this because the caller would
        # need to know the details of what the HTTP body would need to
        # look like.
        parsed_response = {
            'ResponseMetadata': {'HTTPStatusCode': http_status_code},
            'Error': {
                'Message': service_message,
                'Code': service_error_code
            }
        }

        if service_error_meta is not None:
            parsed_response['Error'].update(service_error_meta)

        operation_name = self.client.meta.method_to_api_mapping.get(method)
        # Note that we do not allow for expected_params while
        # adding errors into the queue yet.
        response = {
            'operation_name': operation_name,
            'response': (http_response, parsed_response),
            'expected_params': None
        }
        self._queue.append(response)

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def _add_response(self, method, service_response, expected_params):
        if not hasattr(self.client, method):
            raise ValueError(
                "Client %s does not have method: %s"
                % (self.client.meta.service_model.service_name, method))

        # Create a successful http response
        http_response = Response()
        http_response.status_code = 200
        http_response.reason = 'OK'

        operation_name = self.client.meta.method_to_api_mapping.get(method)
        self._validate_response(operation_name, service_response)

        # Add the service_response to the queue for returning responses
        response = {
            'operation_name': operation_name,
            'response': (http_response, service_response),
            'expected_params': expected_params
        }
        self._queue.append(response)

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def test_get_response_streaming_ok(self):
        http_response = Response()
        http_response.headers = {
            'content-type': 'image/png',
            'server': 'AmazonS3',
            'AcceptRanges': 'bytes',
            'transfer-encoding': 'chunked',
            'ETag': '"00000000000000000000000000000000"',
        }
        http_response.raw = six.BytesIO(b'\x89PNG\r\n\x1a\n\x00\x00')

        http_response.status_code = 200
        http_response.reason = 'OK'

        session = botocore.session.get_session()
        service_model = session.get_service_model('s3')
        operation_model = service_model.operation_model('GetObject')

        res = response.get_response(operation_model, http_response)
        self.assertTrue(isinstance(res[1]['Body'], response.StreamingBody))
        self.assertEqual(res[1]['ETag'],
                         '"00000000000000000000000000000000"')

# 需要导入模块: from botocore.vendored.requests.models import Response [as 别名]
# 或者: from botocore.vendored.requests.models.Response import status_code [as 别名]
    def test_get_response_nonstreaming_ng(self):
        http_response = Response()
        http_response.headers = {
            'content-type': 'application/xml',
            'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
            'server': 'AmazonS3',
            'transfer-encoding': 'chunked',
            'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
            'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
        http_response.raw = six.BytesIO(XMLBODY2)
        http_response.status_code = 200
        http_response.reason = 'ok'
        http_response.request = Request()

        session = botocore.session.get_session()
        service_model = session.get_service_model('s3')
        operation_model = service_model.operation_model('ListObjects')

        self.assertEqual(
            response.get_response(operation_model, http_response)[1],
            {u'Contents': [{u'ETag': '"00000000000000000000000000000000"',
                            u'Key': 'test.png',
                            u'LastModified': datetime.datetime(2014, 3, 1, 17, 6, 40, tzinfo=tzutc()),
                            u'Owner': {u'DisplayName': 'dummy',
                                       u'ID': 'AAAAAAAAAAAAAAAAAAA'},
                            u'Size': 6702,
                            u'StorageClass': 'STANDARD'}],
             u'IsTruncated': False,
             u'Marker': "",
             u'MaxKeys': 1000,
             u'Name': 'mybucket',
             u'Prefix': "",
             'ResponseMetadata': {
                 'RequestId': 'XXXXXXXXXXXXXXXX',
                 'HostId': 'AAAAAAAAAAAAAAAAAAA',
                 'HTTPStatusCode': 200,
             }}
        )