requests.Response

Here are the examples of the python api requests.Response taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

181 Examples 7

Example 1

Project: manila Source File: test_jsonrpc.py
    @patch('time.sleep')
    @patch('requests.Response.close')
    @patch('requests.Session.get')
    @patch('requests.Session.post')
    def test_call_post_202(self, post, get, close, sleep):
        data = {'key': 'value'}
        data2 = {'links': [{'href': 'redirect_url'}]}

        get.return_value = requests.Response()
        post.return_value = requests.Response()
        post.return_value.__setstate__({
            'status_code': 202, '_content': jsonutils.dumps(data2)})
        get.return_value.__setstate__({
            'status_code': 200, '_content': jsonutils.dumps(data)})

        self.assertEqual({'key': 'value'}, self.nef_post('url'))

Example 2

Project: softlayer-python Source File: transport_tests.py
def get_xmlrpc_response():
    response = requests.Response()
    list_body = six.b('''<?xml version="1.0" encoding="utf-8"?>
<params>
<param>
<value>
<array>
<data/>
</array>
</value>
</param>
</params>''')
    response.raw = io.BytesIO(list_body)
    response.headers['SoftLayer-Total-Items'] = 10
    response.status_code = 200
    return response

Example 3

Project: xively-python Source File: tests.py
    def setUp(self):
        super(BaseTestCase, self).setUp()
        self.api = xively.api.XivelyAPIClient("API_KEY")
        self.client = self.api.client
        # Ensure that the jsonified output is in a known order.
        self.client._json_encoder.sort_keys = True
        response = requests.Response()
        response.status_code = 200
        self.request.return_value = self.response = response

Example 4

Project: django-channels Source File: test_twitter.py
    @mock.patch("requests.post")
    def test_send_fail_invalid_token(self, m):
        response = requests.Response()
        response.status_code = requests.codes.unauthorized
        m.return_value = response

        with self.assertRaises(HttpError):
            self.channel.send("Test tweet", fail_silently=False)

        self.channel.send("Test tweet", fail_silently=True)

Example 5

Project: pywikibot-core Source File: http_tests.py
Function: create_request
    @staticmethod
    def _create_request(charset=None, data=UTF8_BYTES):
        """Helper method."""
        req = threadedhttp.HttpRequest('', charset=charset)
        resp = requests.Response()
        resp.headers = {'content-type': 'charset=utf-8'}
        resp._content = data[:]
        req._data = resp
        return req

Example 6

Project: github3.py Source File: test_models.py
Function: set_up
    def setUp(self):
        response = requests.Response()
        response.status_code = 400
        message = b'{"message": "m", "errors": ["e"]}'
        response.raw = io.BytesIO(message)
        self.instance = GitHubError(response)

Example 7

Project: kafka-utils Source File: test_main.py
@mock.patch.object(main.FuturesSession, 'get', autospec=True)
def test_read_cluster_value_exit(mock_get):
    response = mock.Mock(status_code=404, spec=requests.Response)

    request = mock_get.return_value
    request.result.return_value = response

    with pytest.raises(SystemExit):
        p, b = main.read_cluster_status(["host1"], 80, "jolokia")

Example 8

Project: Groupy Source File: test_endpoint.py
Function: fake_response
def fake_response(code=200, errors=None, **kwargs):
    r = requests.Response()
    r.status_code = code
    parcel = envelope(code=code, errors=errors, **kwargs)
    if parcel:
        data = json.dumps(parcel)
    else:
        data = ' '
    r._content = data.encode('utf-8')
    return r

Example 9

Project: ripe-atlas-tools Source File: probe_search.py
    def test_location_arg(self):
        """User passed location arg"""
        with mock.patch('requests.get') as mock_get:
            mock_get.return_value = requests.Response()
            with mock.patch('requests.Response.json') as mock_json:
                mock_json.return_value = {"results": [
                    {"geometry": {"location": {"lat": 1, "lng": 2}}}]}
                cmd = Command()
                cmd.init_args(["--location", "blaaaa"])
                self.assertEquals(cmd.build_request_args(), {'radius': '1,2:15'})

Example 10

Project: streamlink Source File: test_plugin_api_http_session.py
    def test_json_encoding(self):
        json_str = u"{\"test\": \"Α and Ω\"}"

        # encode the json string with each encoding and assert that the correct one is detected
        for encoding in ["UTF-32BE", "UTF-32LE", "UTF-16BE", "UTF-16LE", "UTF-8"]:
            with patch('requests.Response.content', new_callable=PropertyMock) as mock_content:
                mock_content.return_value = json_str.encode(encoding)
                res = requests.Response()

                self.assertEqual(HTTPSession.json(res), {u"test": u"\u0391 and \u03a9"})

Example 11

Project: ansible-kong-module Source File: test_kong_consumer.py
	@mock.patch.object(ModuleHelper, 'get_response')
	@mock.patch.object(AnsibleModule, 'exit_json')
	@mock.patch.object(KongConsumer, 'add')
	@mock.patch.object(ModuleHelper, 'get_module')
	@mock.patch.object(ModuleHelper, 'prepare_inputs')
	def test_main_add(self, mock_prepare_inputs, mock_module, mock_add, mock_exit_json, mock_get_response):

		mock_prepare_inputs.return_value = (mock_kong_admin_url, "1","joesoap", "present", None, None)
		mock_get_response.return_value = (True, requests.Response())
		main()

		assert mock_add.called		

Example 12

Project: puppetboard Source File: test_utils.py
Function: test_http_error
    def test_http_error(self, mock_log):
        err = "NotFound"

        def raise_http_error():
            x = Response()
            x.status_code = 404
            x.reason = err
            raise HTTPError(err, response=x)

        with self.assertRaises(NotFound) as error:
            utils.get_or_abort(raise_http_error)
            mock_log.error.assert_called_with(err)

Example 13

Project: slumber Source File: resource.py
    def test_api(self):
        r = mock.Mock(spec=requests.Response)
        r.status_code = 200
        r.headers = {"content-type": "application/json"}
        r.content = '{"result": ["a", "b", "c"]}'

        client = slumber.API(base_url="http://example/api/v1", session=mock.Mock(spec=requests.Session))
        client.test._store["session"].request.return_value = r
        resp = client.test.get()

        self.assertEqual(resp['result'], ['a', 'b', 'c'])

Example 14

Project: pywikibot-core Source File: http_tests.py
    def test_content_type_application_json_without_charset(self):
        """Test decoding without explicit charset but JSON content."""
        req = CharsetTestCase._create_request()
        resp = requests.Response()
        req._data = resp
        resp._content = CharsetTestCase.UTF8_BYTES[:]
        resp.headers = {'content-type': 'application/json'}
        self.assertIsNone(req.charset)
        self.assertEqual('utf-8', req.encoding)

Example 15

Project: requests-oauthlib Source File: test_oauth1_session.py
Function: verify_signature
    def verify_signature(self, signature):
        def fake_send(r, **kwargs):
            auth_header = r.headers['Authorization']
            if isinstance(auth_header, bytes_type):
                auth_header = auth_header.decode('utf-8')
            self.assertEqual(auth_header, signature)
            resp = mock.MagicMock(spec=requests.Response)
            resp.cookies = []
            return resp
        return fake_send

Example 16

Project: pystmark Source File: test_pystmark.py
Function: mock_response
    def mock_response(self, content, status_code=200, bad_json=False):
        mock = Mock(spec=requests.Response)
        mock.content = content
        mock.ok = (status_code >= 200 and status_code < 300)
        mock.status_code = status_code
        mock.iter_content = lambda size: mock.content
        if bad_json:
            mock.json = self._raise(ValueError)
        else:
            mock.json = lambda: json.loads(mock.content or '""')
        mock.raise_for_status = lambda: None
        return mock

Example 17

Project: github3.py Source File: test_models.py
Function: test_boolean
    def test_boolean(self):
        """Verify boolean tests for response codes correctly."""
        response = requests.Response()
        response.status_code = 200
        boolean = self.instance._boolean(response=response,
                                         true_code=200,
                                         false_code=204)

        assert boolean is True

Example 18

Project: mycroft Source File: test_log_source_action.py
Function: mock_response
    @pytest.yield_fixture(scope='function')
    def mock_response(self):
        with nested(
            mock.patch('mycroft.logic.log_source_action.staticconf.read_bool',
                       autospec=True),
            mock.patch('mycroft.logic.log_source_action.staticconf.read_string',
                       autospec=True),
            mock.patch('mycroft.logic.log_source_action.requests.post',
                       autospec=True)
        ) as (
            read_bool,
            read_string,
            mock_requests_post
        ):
            read_bool.return_value = False
            mock_response = Response()
            mock_requests_post.return_value = mock_response
            yield mock_response

Example 19

Project: commissaire-mvp Source File: test_store_kubestorehandler.py
    def test__store_secret_without_a_valid_secret(self):
        """
        Make sure we don't get empty secrets.
        """
        response = requests.Response()
        response._content = json.dumps({})
        response.status_code = requests.codes.NOT_FOUND
        self.instance._store.get = mock.MagicMock(return_value=response)
        self.assertRaises(KeyError, self.instance._get_secret, 'test')
        self.instance._store.get.assert_called_once()

Example 20

Project: django-tinylinks Source File: check_tinylink_targets_tests.py
Function: test_command
    @patch('requests.get')
    def test_command(self, mock):
        resp = Response()
        resp.status_code = 200
        mock.return_value = resp

        management.call_command('check_tinylink_targets')
        # Run twice, because just one link is checked per interval
        management.call_command('check_tinylink_targets')
        self.assertFalse(
            Tinylink.objects.get(pk=self.tinylink1.id).is_broken,
            msg=('Should not be broken.'),
        )
        self.assertFalse(
            Tinylink.objects.get(pk=self.tinylink2.id).is_broken,
            msg=('Should not be broken.'),
        )

Example 21

Project: ripe-atlas-tools Source File: probe_search.py
    def test_location_google_wrong_output(self):
        """User passed location arg but google api gave not expected format"""
        with mock.patch('requests.get') as mock_get:
            mock_get.return_value = requests.Response()
            with mock.patch('requests.Response.json') as mock_json:
                mock_json.return_value = {"blaaa": "bla"}
                with self.assertRaises(RipeAtlasToolsException):
                    cmd = Command()
                    cmd.init_args(["--location", "blaaaa"])
                    cmd.run()

Example 22

Project: streamlink Source File: test_plugin_api_http_session.py
    def test_json_encoding_override(self):
        json_text = u"{\"test\": \"Α and Ω\"}".encode("cp949")

        with patch('requests.Response.content', new_callable=PropertyMock) as mock_content:
            mock_content.return_value = json_text
            res = requests.Response()
            res.encoding = "cp949"

            self.assertEqual(HTTPSession.json(res), {u"test": u"\u0391 and \u03a9"})

Example 23

Project: requests-cache Source File: base.py
    def restore_response(self, response, seen=None):
        """ Restore response object after unpickling
        """
        if seen is None:
            seen = {}
        try:
            return seen[id(response)]
        except KeyError:
            pass
        result = requests.Response()
        for field in self._response_attrs:
            setattr(result, field, getattr(response, field, None))
        result.raw._cached_content_ = result.content
        seen[id(response)] = result
        result.history = tuple(self.restore_response(r, seen) for r in response.history)
        return result

Example 24

Project: ripe-atlas-tools Source File: probe_search.py
    def test_location_arg_with_radius(self):
        """User passed location arg"""
        with mock.patch('requests.get') as mock_get:
            mock_get.return_value = requests.Response()
            with mock.patch('requests.Response.json') as mock_json:
                mock_json.return_value = {"results": [
                    {"geometry": {"location": {"lat": 1, "lng": 2}}}
                ]}
                cmd = Command()
                cmd.init_args(["--location", "blaaaa", "--radius", "4"])
                self.assertEquals(
                    cmd.build_request_args(),
                    {"radius": "1,2:4"}
                )

Example 25

Project: ansible-kong-module Source File: test_kong_consumer.py
	@mock.patch.object(ModuleHelper, 'get_response')
	@mock.patch.object(AnsibleModule, 'exit_json')
	@mock.patch.object(KongConsumer, 'delete')
	@mock.patch.object(ModuleHelper, 'get_module')
	@mock.patch.object(ModuleHelper, 'prepare_inputs')
	def test_main_delete(self, mock_prepare_inputs, mock_module, mock_delete, mock_exit_json, mock_get_response):

		mock_prepare_inputs.return_value = (mock_kong_admin_url, "1","joesoap", "absent", None, None)
		mock_get_response.return_value = (True, requests.Response())
		main()

		assert mock_delete.called		

Example 26

Project: ansible-kong-module Source File: test_kong_consumer.py
	@mock.patch.object(ModuleHelper, 'get_response')
	@mock.patch.object(AnsibleModule, 'exit_json')
	@mock.patch.object(KongConsumer, 'list')
	@mock.patch.object(ModuleHelper, 'get_module')
	@mock.patch.object(ModuleHelper, 'prepare_inputs')
	def test_main_list(self, mock_prepare_inputs, mock_module, mock_list, mock_exit_json, mock_get_response):

		mock_prepare_inputs.return_value = (mock_kong_admin_url, "1","joesoap", "list", None, None)
		mock_get_response.return_value = (True, requests.Response())
		main()

		assert mock_list.called			

Example 27

Project: raco Source File: errors.py
Function: init
    def __init__(self, err=None):
        if isinstance(err, requests.Response):
            msg = 'Error {} ({})'.format(err.status_code, err.reason)
            if err.text:
                msg = '{}: {}'.format(msg, err.text)
            Exception.__init__(self, msg)
        else:
            Exception.__init__(self, err)

Example 28

Project: slumber Source File: resource.py
    def test_handle_serialization(self):
        self.base_resource._store.update({
            "serializer": slumber.serialize.Serializer(),
        })

        resp = mock.Mock(spec=requests.Response)
        resp.status_code = 200
        resp.headers = {"content-type": "application/json; charset=utf-8"}
        resp.content = '{"foo": "bar"}'

        r = self.base_resource._try_to_serialize_response(resp)

        if not isinstance(r, dict):
            self.fail("Serialization did not take place")

Example 29

Project: puppetboard Source File: test_utils.py
    def test_http_connection_error(self, mock_log):
        err = "ConnectionError"

        def connection_error():
            x = Response()
            x.status_code = 500
            x.reason = err
            raise ConnectionError(err, response=x)

        with self.assertRaises(InternalServerError) as error:
            utils.get_or_abort(connection_error)
            mock_log.error.assert_called_with(err)

Example 30

Project: requests-oauthlib Source File: test_oauth1_session.py
    def test_fetch_token_invalid_response(self):
        auth = OAuth1Session('foo')
        auth.send = self.fake_body('not valid urlencoded response!')
        self.assertRaises(ValueError, auth.fetch_request_token,
                'https://example.com/token')

        for code in (400, 401, 403):
            auth.send = self.fake_body('valid=response', code)
            # use try/catch rather than self.assertRaises, so we can
            # assert on the properties of the exception
            try:
                auth.fetch_request_token('https://example.com/token')
            except ValueError as err:
                self.assertEqual(err.status_code, code)
                self.assertTrue(isinstance(err.response, requests.Response))
            else:  # no exception raised
                self.fail("ValueError not raised")

Example 31

Project: pywikibot-core Source File: http_tests.py
    def test_no_charset(self):
        """Test decoding without explicit charset."""
        req = threadedhttp.HttpRequest('')
        resp = requests.Response()
        resp.headers = {'content-type': ''}
        resp._content = CharsetTestCase.LATIN1_BYTES[:]
        req._data = resp
        self.assertIsNone(req.charset)
        self.assertEqual('latin1', req.encoding)
        self.assertEqual(req.raw, CharsetTestCase.LATIN1_BYTES)
        self.assertEqual(req.content, CharsetTestCase.STR)

Example 32

Project: python-scaleway Source File: test_api.py
Function: test_serialize
    def test_serialize(self):
        api = SimpleAPI()
        self.fake_endpoint(api, 'whatever/', status=200, body='xxx')

        response = api.query(serialize=False).whatever.get()
        self.assertIsInstance(response, requests.Response)

        response = api.query(serialize=True).whatever.get()
        try:
            self.assertIsInstance(response, unicode)
        except NameError:  # python3
            self.assertIsInstance(response, str)

Example 33

Project: xively-python Source File: __init__.py
def handle_request(method, url, *args, **kwargs):
    response = requests.Response()
    response.status_code = 200
    relative_url = url.replace("http://api.xively.com/v2/", '')
    if relative_url in responses_by_url:
        response.raw = BytesIO(responses_by_url[relative_url])
    return response

Example 34

Project: commissaire-mvp Source File: test_store_kubestorehandler.py
Function: test_get_secret
    def test__get_secret(self):
        """
        Verify secret retrieval works properly.
        """
        response = requests.Response()
        response._content = json.dumps({'data': {'test': 'dGVzdA==\n'}})
        response.status_code = requests.codes.OK
        self.instance._store.get = mock.MagicMock(return_value=response)
        result = self.instance._get_secret('test')
        self.instance._store.get.assert_called_once()
        self.assertEquals({'test': 'test'}, result)

Example 35

Project: YCM_WIN_X86 Source File: test_requests.py
    def test_response_is_iterable(self):
        r = requests.Response()
        io = StringIO.StringIO('abc')
        read_ = io.read

        def read_mock(amt, decode_content=None):
            return read_(amt)
        setattr(io, 'read', read_mock)
        r.raw = io
        assert next(iter(r))
        io.close()

Example 36

Project: github3.py Source File: test_models.py
    def test_message_is_empty(self):
        """Verify instance message is correct."""
        response = requests.Response()
        response.status_code = 400
        response.raw = io.BytesIO()
        error = GitHubError(response)
        assert error.message == '[No message]'

Example 37

Project: kafka-utils Source File: test_main.py
@mock.patch.object(main.FuturesSession, 'get', autospec=True)
def test_read_cluster_value_partitions(mock_get):
    response = mock.Mock(status_code=200, spec=requests.Response)
    response.json.return_value = {'value': 1}

    request = mock_get.return_value
    request.result.return_value = response

    p, b = main.read_cluster_status(["host1", "host2", "host3"], 80, "jolokia")

    assert p == 3   # 3 missing partitions
    assert b == 0   # 0 missing brokers

Example 38

Project: requests-oauthlib Source File: test_oauth1_session.py
    def fake_body(self, body, status_code=200):
        def fake_send(r, **kwargs):
            resp = mock.MagicMock(spec=requests.Response)
            resp.cookies = []
            resp.text = body
            resp.status_code = status_code
            return resp
        return fake_send

Example 39

Project: kafka-utils Source File: test_main.py
@mock.patch.object(main.FuturesSession, 'get', autospec=True)
def test_read_cluster_value_no_key(mock_get):
    response = mock.Mock(status_code=200, spec=requests.Response)
    response.json.return_value = {'wrong_key': 1}

    request = mock_get.return_value
    request.result.return_value = response

    p, b = main.read_cluster_status(["host1"], 80, "jolokia")

    assert p == 0   # 0 missing partitions
    assert b == 1   # 1 missing brokers

Example 40

Project: github3.py Source File: test_models.py
Function: test_json
    def test_json(self):
        """Verify JSON information is retrieved correctly."""
        response = requests.Response()
        response.headers['Last-Modified'] = 'foo'
        response.headers['ETag'] = 'bar'
        response.raw = io.BytesIO(b'{}')
        response.status_code = 200

        json = self.instance._json(response, 200)
        assert json['Last-Modified'] == 'foo'
        assert json['ETag'] == 'bar'

Example 41

Project: django-channels Source File: test_twitter.py
Function: test_send
    @mock.patch("requests.post")
    def test_send(self, m):
        response = requests.Response()
        response.status_code = requests.codes.ok
        m.return_value = response

        self.channel.send("First tweet!")

Example 42

Project: flex Source File: http.py
def _normalize_requests_response(response, request=None):
    import requests
    if not isinstance(response, requests.Response):
        raise TypeError("Cannot normalize this response object")

    url = response.url
    status_code = response.status_code
    content_type = response.headers.get('Content-Type')

    return Response(
        request=request,
        content=response.content,
        url=url,
        status_code=status_code,
        content_type=content_type,
        response=response,
    )

Example 43

Project: django-channels Source File: test_yo.py
Function: test_send
    @mock.patch("requests.post")
    def test_send(self, m):
        response = requests.Response()
        response.status_code = requests.codes.ok
        m.return_value = response

        # Just Yo
        self.channel.send(None)

        # Yo with text
        self.channel.send("🍣")

        # Yo Link
        self.channel.send(None, options={
            "yo": {"link": "http://docs.justyo.co/v1.0/docs/yo"}})

        # Yo Location
        self.channel.send(None, options={
            "yo": {"location": "35.0261581,135.7818476"}})

Example 44

Project: pyoauth2 Source File: provider.py
Function: make_response
    def _make_response(self, body='', headers=None, status_code=200):
        """Return a response object from the given parameters.

        :param body: Buffer/string containing the response body.
        :type body: str
        :param headers: Dict of headers to include in the requests.
        :type headers: dict
        :param status_code: HTTP status code.
        :type status_code: int
        :rtype: requests.Response
        """
        res = Response()
        res.status_code = status_code
        if headers is not None:
            res.headers.update(headers)
        res.raw = StringIO(body)
        return res

Example 45

Project: ansible-kong-module Source File: test_kong_consumer.py
	@mock.patch.object(ModuleHelper, 'get_response')
	@mock.patch.object(AnsibleModule, 'exit_json')
	@mock.patch.object(KongConsumer, 'configure_for_plugin')
	@mock.patch.object(ModuleHelper, 'get_module')
	@mock.patch.object(ModuleHelper, 'prepare_inputs')
	def test_main_list(self, mock_prepare_inputs, mock_module, mock_configure_for_plugin, mock_exit_json, mock_get_response):

		mock_prepare_inputs.return_value = (mock_kong_admin_url, "1","joesoap", "configure", "auth-key", {"key": "123"})
		mock_get_response.return_value = (True, requests.Response())
		main()

		assert mock_configure_for_plugin.called				

		expected_call = call('1', 'auth-key', {'key': '123'})
		assert mock_configure_for_plugin.call_args_list[0] == expected_call

Example 46

Project: vdirsyncer Source File: test_caldav.py
    def test_invalid_resource(self, monkeypatch, get_storage_args):
        calls = []
        args = get_storage_args(collection=None)

        def request(session, method, url, **kwargs):
            assert url == args['url']
            calls.append(None)

            r = requests.Response()
            r.status_code = 200
            r._content = 'Hello World.'
            return r

        monkeypatch.setattr('requests.sessions.Session.request', request)

        with pytest.raises(ValueError):
            s = self.storage_class(**args)
            list(s.list())
        assert len(calls) == 1

Example 47

Project: atomic-reactor Source File: test_add_yum_repo_by_url.py
def prepare():
    if MOCK:
        mock_docker()
    tasker = DockerTasker()
    workflow = DockerBuildWorkflow({"provider": "git", "uri": DOCKERFILE_GIT}, "test-image")
    setattr(workflow, 'builder', X())

    setattr(workflow.builder, 'image_id', "asd123")
    setattr(workflow.builder, 'base_image', ImageName(repo='Fedora', tag='21'))
    setattr(workflow.builder, 'source', X())
    setattr(workflow.builder.source, 'dockerfile_path', None)
    setattr(workflow.builder.source, 'path', None)
    (flexmock(requests.Response, content=repocontent)
        .should_receive('raise_for_status')
        .and_return(None))
    (flexmock(requests, get=lambda *_: requests.Response()))
    return tasker, workflow

Example 48

Project: mopidy-pandora Source File: test_utils.py
def test_do_rpc():
    utils.RPCClient.configure('host_mock', 'port_mock')
    assert utils.RPCClient.hostname == 'host_mock'
    assert utils.RPCClient.port == 'port_mock'

    response_mock = mock.PropertyMock(spec=requests.Response)
    response_mock.text = '{"result": "result_mock"}'
    requests.request = mock.PropertyMock(return_value=response_mock)

    q = queue.Queue()
    utils.RPCClient._do_rpc('method_mock',
                            params={'param_mock_1': 'value_mock_1', 'param_mock_2': 'value_mock_2'},
                            queue=q)

    assert q.get() == 'result_mock'

Example 49

Project: pyrollbar Source File: __init__.py
def _post_api_twisted(path, payload, access_token=None):
    def post_data_cb(data, resp):
        resp._content = data
        _parse_response(path, SETTINGS['access_token'], payload, resp)

    def post_cb(resp):
        r = requests.Response()
        r.status_code = resp.code
        r.headers.update(resp.headers.getAllRawHeaders())
        return treq.content(resp).addCallback(post_data_cb, r)

    headers = {'Content-Type': ['application/json']}
    if access_token is not None:
        headers['X-Rollbar-Access-Token'] = [access_token]

    url = urljoin(SETTINGS['endpoint'], path)
    d = treq.post(url, payload, headers=headers,
                  timeout=SETTINGS.get('timeout', DEFAULT_TIMEOUT))
    d.addCallback(post_cb)

Example 50

Project: freight_forwarder Source File: registry_base.py
Function: validate_response
    def _validate_response(self, response):
        if not isinstance(response, requests.Response):
            raise TypeError("validate response requires the response argument to be a requests.Response object.")

        if hasattr(response, 'status_code') and not (response.status_code >= 200 and response.status_code < 300):
            raise RegistryException(response)

        return response.ok
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3 Page 4