Python Response.reason方法代码示例

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
def build_response(request,
                   status_code=200,
                   headers={},
                   content='(none)'):
    """
    Build a :class:`requests.Response` object on the basis of the passed
    parameters.
    """

    response = Response()

    response.status_code = status_code
    response.reason = responses[status_code]
    response.headers = CaseInsensitiveDict(headers)
    # Pretend that we've already read from the socket
    response._content = content

    response.encoding = get_encoding_from_headers(response.headers)
    response.url = request.url
    response.raw = MockRawResponse()

    # Give the Response some context.
    response.request = request
    response.connection = MockConnection()

    return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
 def make_response(self, status_code=200, reason='OK', data=None):
     data = data or {}
     response = Response()
     response.status_code = status_code
     response.reason = reason
     response._content = json.dumps(data).encode('utf-8')
     return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
def make_response(code, message):
    """
    Create a ``requests.Response`` with the given response code and message.

    :param int code: The HTTP response code to include in the fake response.
    :param unicode message: The HTTP response message to include in the fake
        response.  The message will be encoded using ASCII.
    """
    response = Response()
    response.status_code = code
    response.reason = message
    return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
    def test_delete_operation_on_cloud_any_error_throws_exception(self):
        # Arrange
        response = Response()
        response.status_code = 0
        response.reason = "Bla bla error"
        error = CloudError(response)
        self.vm_service.delete_vm = Mock(side_effect=error)

        # Act
        self.assertRaises(Exception,
                          self.delete_operation.delete,
                          Mock(),
                          Mock(),
                          "AzureTestGroup",
                          "AzureTestVM")

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
    def encode(self, onem2m_primitive):
        """
        Encodes OneM2M JSON primitive object to Rx specific HTTP message
        with JSON content type
        """

        # This is Rx encoder so we use Response
        msg = Response()

        params = onem2m_primitive.get_parameters()
        proto_params = onem2m_primitive.get_protocol_specific_parameters()

        # set result code and reason
        if http_result_code not in proto_params:
            raise IoTDataEncodeError("Result code not passed for HTTP response")

        result_code = proto_params[http_result_code]
        try:
            reason = status_codes._codes[result_code][0]
        except KeyError:
            raise IoTDataEncodeError("Invalid result code passed: {}", result_code)

        msg.status_code = result_code
        msg.reason = reason

        # Headers from protocol specific parameters
        if proto_params:
            for key, value in proto_params.items():
                encoded = http_headers.encode_default_ci(key, None)
                if None is not encoded:
                    msg.headers[encoded] = str(value)

        # onem2m parameters
        for key, value in params.items():
            encoded = http_headers.encode_default_ci(key, None)
            if None is not encoded:
                msg.headers[encoded] = str(value)

        # Body (content)
        content = onem2m_primitive.get_content()
        if content:
            msg._content = content

        return msg

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
        def fake_send(self, request):
            g = parser.match(request.url).groups()

            response = Response()
            response.url = g[0]
            response.reason = g[1]
            response.status_code = int(g[2])
            if g[3] is not None:
                wait = float(g[3])
            else:
                wait = defaultSendTime - 0.001 # Epsilon, since sleep is defined as "will wait at *least* as long as..."

            sleep(wait)

            if response.status_code >= 600:
                # Special case for testing exception handling
                raise Exception('[%d] %s' % ( response.status_code, response.reason ))

            return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
    def test_delete_operation_on_cloud_error_not_found_no_exception(self):
        # Arrange
        response = Response()
        response.status_code = 0
        response.reason = "Not Found"
        error = CloudError(response)
        self.vm_service.delete_vm = Mock(side_effect=error)
        self.delete_operation.security_group_service.delete_security_rules = Mock()

        # Act
        self.delete_operation.delete(
                Mock(),
                Mock(),
                Mock(),
                "group_name",
                "vm_name",
                self.logger)

        # Verify
        self.logger.info.assert_called()

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
    def test_negative_retry(self):
        retry_max = 100
        retry_wait = 0
        retry_range = 10

        client = Client(TEST_ENDPOINT, retry_max=retry_max, retry_wait=retry_wait, retry_range=retry_range)
        err_response = Response()
        err_response.status_code = 500
        err_response.reason = "INTERNAL SERVER ERROR"

        adapter = RepeatingTestAdapter(err_response)
        client._session.mount(TEST_ENDPOINT, adapter)

        mock_sleep = MockTimeSleep()

        with mock_sleep:
            self.assertRaises(APIError, client.measurements.list)

        for wait_time in mock_sleep.calls:
            self.assertGreaterEqual(wait_time, 0)

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
    def test_error_wrapping(self):
        """
        Test that HTTP errors are wrapped into API Errors
        """
        client = Client(TEST_ENDPOINT)
        response = Response()
        response.status_code = 500
        response.reason = "INTERNAL SERVER ERROR"
        adapter = RepeatingTestAdapter(response)

        client._session.mount(TEST_ENDPOINT, adapter)

        # We want a bit more control than just assertRaises
        try:
            client.measurements.get()
        except APIError as e:
            self.assertIsNotNone(e.response)
            self.assertEqual(500, e.response.status_code)
            self.assertEqual("INTERNAL SERVER ERROR", e.response.reason)
        else:
            self.fail("No APIError was raised")

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
    def test_retry(self):
        retry_max = 2
        retry_wait = 7

        client = Client(TEST_ENDPOINT, retry_max=retry_max, retry_wait=retry_wait)

        err_response = Response()
        err_response.status_code = 500
        err_response.reason = "INTERNAL SERVER ERROR"

        response_data = dict(BASE_RESPONSE)
        response_data["objects"] = [OBJ_1_PARTIAL]
        response_data["total_count"] = 1
        success_response = make_json_response(response_data)

        adapter = PredictableTestAdapter([err_response, err_response, success_response])
        client._session.mount(TEST_ENDPOINT, adapter)

        mock_sleep = MockTimeSleep()

        with mock_sleep:
            try:
                 response = client.measurements.list()
            except APIError as e:
                self.fail("API call wasn't retried: %s" % e)

        self.assertEqual([OBJ_1_PARTIAL], response)
        self.assertEqual([retry_wait, retry_wait], mock_sleep.calls)


        adapter = PredictableTestAdapter([err_response, err_response, err_response, success_response])
        client._session.mount(TEST_ENDPOINT, adapter)

        mock_sleep = MockTimeSleep()

        with mock_sleep:
            self.assertRaises(APIError, client.measurements.list)

        self.assertEqual([retry_wait, retry_wait], mock_sleep.calls)

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
    def test_random_retry(self):
        retry_max = 50  # We want a large sample
        retry_wait = 100
        retry_range = 5

        client = Client(TEST_ENDPOINT, retry_max=retry_max, retry_wait=retry_wait, retry_range=retry_range)
        err_response = Response()
        err_response.status_code = 500
        err_response.reason = "INTERNAL SERVER ERROR"

        adapter = RepeatingTestAdapter(err_response)
        client._session.mount(TEST_ENDPOINT, adapter)

        mock_sleep = MockTimeSleep()

        with mock_sleep:
            self.assertRaises(APIError, client.measurements.list)

        for wait_time in mock_sleep.calls:
            self.assertGreaterEqual(wait_time, retry_wait - retry_range)
            self.assertLessEqual(wait_time, retry_wait + retry_range)

        self.assertFalse(all([wait_time == retry_wait for wait_time in mock_sleep.calls]))

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
    def test_race_condition(self):
        self.client = Client(TEST_ENDPOINT)  # We'll never hit that anyway

        response_data = dict(BASE_RESPONSE)

        absent = make_json_response(response_data)

        exists = Response()
        exists.status_code = 400
        exists.reason = "BAD REQUEST"
        exists._content = six.b('{"configuration": {"__all__": ["Configuration with this I/O Mode, Block Size and I/O Depth already exists."]}}')

        response_data = dict(BASE_RESPONSE)
        response_data["objects"] = [OBJ_1_PARTIAL]
        response_data["total_count"] = 1
        success_response = make_json_response(response_data)

        self.adapter = PredictableTestAdapter([absent, exists, success_response, make_json_response(OBJ_RESPONSE)])
        self.client._session.mount(TEST_ENDPOINT, self.adapter)

        ret = self.client.configurations.get_or_create()
        self.assertDictEqual(OBJ_RESPONSE, ret)
        self.assertEqual(4, len(self.adapter.requests))

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
    def build_response(self, req, resp):
        response = Response()

        response.status_code = resp.status_code
        response.headers = CaseInsensitiveDict((k, v) for k, v in resp.items())

        response.encoding = get_encoding_from_headers(response.headers)
        response.raw = StringIO(resp.content)
        response.reason = None

        if isinstance(req.url, bytes):
            response.url = req.url.decode('utf-8')
        else:
            response.url = req.url

        # Convert from django's SimpleCookie to request's CookieJar
        cookiejar_from_dict(resp.cookies, response.cookies)

        # context
        response.request = req
        response.connection = self

        response = dispatch_hook('response', req.hooks, response)
        return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
def build_response(reason=None, status_code=200, headers={}):
  response = Response()
  response.status_code = status_code
  response.headers = headers
  response.reason = reason
  return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import reason [as 别名]
 def connection_error():
     x = Response()
     x.status_code = 500
     x.reason = err
     raise ConnectionError(err, response=x)