Python requests.Response类代码示例

    def get_http_request(url, payload, method='POST', headers=None, use_proxy=False, use_proxy_auth=False, trust_env=True):
        try:
            session = Session()
            session.trust_env = trust_env
            session.proxies = Util.get_proxies() if use_proxy else None
            session.auth = Util.get_proxy_auth() if use_proxy_auth else None

            request = Request(
                'POST' if method not in ('GET', 'POST') else method,
                url,
                data=payload if method == 'POST' else None,
                params=payload if method == 'GET' else None,
                headers=headers
            )

            prepped = request.prepare()

            response = session.send(
                prepped,
                timeout=app.config['HTTP_REQUESTS_TIMEOUT']
            )

            session.close()
        except Exception, e:
            response = Response()
            response.raise_for_status()
            return response, 'Error al realizar la consulta - Motivo: {}'.format(e.message)

def create_response(**kw):
    r = Response()
    r._content = b''
    r.status = 200
    for k, v in kw.items():
        setattr(r, k, v)
    return r

def test_reset_rabbit_connection_errors():

    rabbit_manager = Mock()

    with patch('nameko.testing.utils.get_rabbit_connections') as connections:
        connections.return_value = [{
            'vhost': 'vhost_name',
            'name': 'connection_name'
        }]

        # 500 error
        response_500 = Response()
        response_500.status_code = 500
        error_500 = HTTPError(response=response_500)
        rabbit_manager.delete_connection.side_effect = error_500

        with pytest.raises(HTTPError):
            reset_rabbit_connections("vhost_name", rabbit_manager)

        # 404 error
        response_404 = Response()
        response_404.status_code = 404
        error_404 = HTTPError(response=response_404)
        rabbit_manager.delete_connection.side_effect = error_404

        # does not raise
        reset_rabbit_connections("vhost_name", rabbit_manager)

    def test_download_fails_due_to_hash_mismatch(self):
        snap_content = b'1234567890'
        mock_details = self.mock_get.return_value
        mock_details.ok = True
        mock_details.content = json.dumps({
            '_embedded': {
                    'clickindex:package': [{
                        'download_url': 'http://localhost',
                        'anon_download_url': 'http://localhost',
                        'download_sha512': '12345',
                    }],
            }
        }).encode('utf-8')
        mock_snap = Response()
        mock_snap.status_code = 200
        mock_snap._content = snap_content

        self.mock_get.side_effect = [mock_details, mock_snap]

        with self.assertRaises(RuntimeError) as raised:
            download('os', 'edge', 'os.snap', None, 'amd64')

        self.assertEqual("Failed to download 'os'", str(raised.exception))
        self.mock_logger.info.assert_has_calls([
            call("Getting details for 'os'"),
            call("Downloading 'os'")])
        self.assertTrue(os.path.exists('os.snap'))

    def test_get_token_with_scope(self, get_token):
        the_response = Response()
        the_response.status_code = 200
        the_response.json = MagicMock(return_value={'access_token': 'foobar'})
        get_token.return_value = the_response

        block = OAuthBlock()
        self.configure_block(block, {})
        token = block.get_access_token(
            'user', 'pass',
            scope='my-scope',
            addl_params={
                'extra': 'value'
            })

        self.assertEqual(token['access_token'], 'foobar')
        self.assertEqual(block.get_access_token_headers(), {
            'Authorization': 'Bearer foobar'
        })

        get_token.assert_called_once_with(
            'http://oauthbase/token',
            data={
                'username': 'user',
                'password': 'pass',
                'scope': 'my-scope',
                'grant_type': 'password',
                'extra': 'value'
            })

 async def did_receive_response(
     self,
     response: requests.Response,
     request: Request
 ) -> typing.Any:
     response.raise_for_status()
     return response.json(object_hook=self.convert_to_object)

 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

    def __init__(self):
        """Use response.text have performance problem, use response.html fix it.
        This is an issue, maybe some init charset not set, requests use chardet
        library to detect charset of the html content.

        """
        ResponseLib.__init__(self)

    def test_token(self, mock_head, mock_post, mock_service_creds):

        # mock out the token request response
        the_response = Response()
        the_response.status_code = 200
        the_response.json = MagicMock(return_value={'access_token': 'foobar'})
        mock_post.return_value = the_response

        block = OAuthBlock()
        self.configure_block(block, {
            "key_config_file": "tests/KEY_FILE_GOES_HERE.json"
        })

        token = block.get_access_token(
            'https://www.googleapis.com/auth/analytics.readonly')

        self.assertEqual(token['access_token'], 'foobar')

        # Oauth2ServiceAccount.get_access_token is mocked, so
        # Oauth2ServiceAccount.parse_token_from_response(r) is never called,
        # and self._oauth_token is never assigned.
        # Need to assign it here before checking block.get_access_token_headers
        block._oauth_token = {'access_token': 'foobar'}
        self.assertEqual(block.get_access_token_headers(), {
            'Authorization': 'Bearer foobar'
        })

def get_acacess_token_app(tenant_id,client_id,client_secret,resource):
    initialise()
    
    url = "https://login.windows.net/" + tenant_id + "/oauth2/token"        
    
    body_data = "&grant_type=client_credentials&resource="+ resource +"&client_id="+ client_id + "&client_secret="+  urllib.quote_plus(client_secret)
    
    headers = {"Content-Type":"application/x-www-form-urlencoded"}
    req = Request(method="POST",url=url,data=body_data)
    req_prepped = req.prepare()
    s = Session()
    res = Response()
    res = s.send(req_prepped)
    access_token_det = {}
    if (res.status_code == 200):
        responseJSON = json.loads(res.content)
        access_token_det["details"]= responseJSON["access_token"]
        access_token_det["status"]="1"
        access_token_det["exp_time"]=responseJSON["expires_in"]
        access_token_det["exp_date"]=responseJSON["expires_on"]
        access_token_det["accessDetails"]=responseJSON
    else:
        access_token_det["details"]= str(res.status_code) + str(res.json())
        access_token_det["status"]="0"
    return access_token_det

def parse_arrivals_from_infotrafic(line_id: int, stations: Dict[str, Station], response: requests.Response, include_unknown_stations: bool = False) -> Tuple[List[Tuple[Union[Station,str], Arrival]]]:
	response.raise_for_status()
	if response.status_code == requests.codes.ok:
		bs = bs4.BeautifulSoup(response.text, "html.parser")
		prevcolor = None
		datacolor = '00BFFF'
		routes = []
		route = None
		tz = pytz.timezone("Europe/Bucharest")
		now = tzlocal.get_localzone().localize(datetime.now()).astimezone(tz).replace(second=0, microsecond=0)
		for row in bs.find_all("table"):
			if row['bgcolor'] == datacolor:
				if prevcolor != datacolor:
					route = []
					routes.append(route)

				cols = row.find_all("b")
				raw_station_name = cols[1].text.strip()
				station = stations.get(raw_station_name, None)
				arrival = parse_arrival(now, line_id, station.station_id if station else -1, cols[2].text)
				if station is not None or include_unknown_stations:
					route.append((station if station is not None else raw_station_name, arrival))

			prevcolor = row['bgcolor']

		return routes if route else None

	return None

    def test_get_json_data(self, gobase_get_full_response):
        response = Response()
        response._content = "not a json object"
        gobase_get_full_response.return_value = response

        with self.assertRaises(GoCdApiException):
            self.gobase.get_json_data(self.gobase.url)

    def logged_in(self, login='fred', travis_user=True):
        """ A context manager to do stuff, while logged in as fred. """

        response = Response()
        response._content = json.dumps(
            dict(id=12345, login=login, name='Fred')
        )
        data = Mock()
        data.get = Mock(return_value=response)
        data.access_token = GH_TOKEN

        true = Mock(return_value=True)

        if travis_user:
            travis_patch = patch('travis_utils.is_travis_user', true)
            travis_patch.start()

        with patch('statiki.github', Mock(spec=OAuth2Service)) as gh:
            gh.get_auth_session = Mock(return_value=data)

            try:
                yield self.app.get('/authorized?code="bazooka"')

            finally:
                if travis_user:
                    travis_patch.stop()

                self.app.get('/logout')

def test_yahoo_get_by_date(yahoo, logger):
    sample = Response()
    sample.status_code = 200
    sample._content = YAHOO_RESPONSE
    yahoo._get = lambda *a, **kw: sample

    assert yahoo.get_by_date(date.today(), "CZK", logger) == Decimal("25.959")

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