def test_disable_default_redirect_cache(self, mock_request): """ Test disable default redirect cache (by setting default redirect cache to None) """ response0 = Response() response0.url = 'http://www.test.com/neverseemeagain' response0.status_code = 301 response0.headers = { 'Location': 'http://www.test.com/redirect_here', } response1 = Response() response1.url = 'http://www.test.com/redirect_here' response1.status_code = 200 response1._content = 'Mocked response content' response1.headers = { 'Vary': 'Accept', } response1.history = [response0] mock_request.return_value = response1 get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/neverseemeagain', allow_redirects=True) get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/redirect_here', allow_redirects=True) set_default_redirect_cache(None) get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/neverseemeagain', allow_redirects=True) get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/neverseemeagain', allow_redirects=True)
def test_get_301_circular_redirect(self, mock_request): response0 = Response() response0.url = 'http://www.test.com/path0' response0.status_code = 301 response0.headers = {'Location': 'http://www.test.com/path1'} response1 = Response() response1.url = 'http://www.test.com/path1' response1.status_code = 301 response1.headers = {'Location': 'http://www.test.com/path0'} response2 = Response() response2.url = 'http://www.test.com/path2' response2.status_code = 200 response2._content = 'Mocked response content' response2.history = [response0, response1] mock_request.return_value = response2 r = get('http://www.test.com/path0') self.assertEqual(mock_request.call_count, 1) self.assertEqual(r.status_code, 200) self.assertEqual(r.content, 'Mocked response content') with self.assertRaises(TooManyRedirects): get('http://www.test.com/path0')
def test_get_301_only_once(self, mock_request): response0 = Response() response0.url = 'http://www.test.com/neverseemeagain' response0.status_code = 301 response0.headers = { 'Location': 'http://www.test.com/redirect_here', } response1 = Response() response1.url = 'http://www.test.com/redirect_here' response1.status_code = 200 response1._content = 'Mocked response content' response1.headers = { 'Vary': 'Accept', } response1.history = [response0] mock_request.return_value = response1 r = get('http://www.test.com/neverseemeagain') self.assertEqual(mock_request.call_count, 1) mock_request.assert_called_with('GET', 'http://www.test.com/neverseemeagain', allow_redirects=True) self.assertEqual(r.status_code, 200) #assert we not make request to 301 again r = get('http://www.test.com/neverseemeagain') self.assertEqual(mock_request.call_count, 2) mock_request.assert_called_with('GET', 'http://www.test.com/redirect_here', allow_redirects=True) self.assertEqual(r.status_code, 200)
def get(url, **kwargs): resp_basic_auth = Response() resp_basic_auth.status_code = 200 if "authenticate" in url: if kwargs["auth"].password != "PASSWORD!": raise Exception("Bad password") resp_basic_auth._content = b"TOKEN" resp_basic_auth.headers = {"Content-Type": "text/plain"} elif "ping" in url: token = getattr(kwargs["auth"], "token", None) password = getattr(kwargs["auth"], "password", None) if token and token != "TOKEN": raise Exception("Bad JWT Token") if not token and not password: raise AuthenticationException( "I'm an Artifactory without anonymous access that " "requires authentication for the ping endpoint and " "I don't return the capabilities") elif "search" in url: if kwargs["auth"].token != "TOKEN": raise Exception("Bad JWT Token") resp_basic_auth._content = b'{"results": []}' resp_basic_auth.headers = { "Content-Type": "application/json" } else: raise Exception("Shouldn't be more remote calls") return resp_basic_auth
def test_get_301_thrice(self, mock_get): response0 = Response() response0.url = 'http://www.test.com/neverseemeagain' response0.status_code = 301 response0.headers = { 'Location': 'http://www.test.com/redirect_1', } response1 = Response() response1.url = 'http://www.test.com/redirect_1' response1.status_code = 301 response1.headers = { 'Location': 'http://www.test.com/redirect_2', } response2 = Response() response2.url = 'http://www.test.com/redirect_2' response2.status_code = 301 response2.headers = { 'Location': 'http://www.test.com/redirect_3', } response3 = Response() response3.url = 'http://www.test.com/redirect_3' response3.status_code = 200 response3._content = 'Mocked response content' response3.headers = { 'Vary': 'Accept', } response3.history = [response0, response1, response2] mock_get.return_value = response3 r = get('http://www.test.com/neverseemeagain') self.assertEqual(mock_get.call_count, 1) mock_get.assert_called_with('http://www.test.com/neverseemeagain') self.assertEqual(r.status_code, 200) #assert we not make request to 301 again r = get('http://www.test.com/neverseemeagain') self.assertEqual(mock_get.call_count, 2) mock_get.assert_called_with('http://www.test.com/redirect_3') self.assertEqual(r.status_code, 200) r = get('http://www.test.com/redirect_1') self.assertEqual(mock_get.call_count, 3) mock_get.assert_called_with('http://www.test.com/redirect_3') self.assertEqual(r.status_code, 200) r = get('http://www.test.com/redirect_2') self.assertEqual(mock_get.call_count, 4) mock_get.assert_called_with('http://www.test.com/redirect_3') self.assertEqual(r.status_code, 200) r = get('http://www.test.com/redirect_3') self.assertEqual(mock_get.call_count, 5) mock_get.assert_called_with('http://www.test.com/redirect_3') self.assertEqual(r.status_code, 200)
def test_domain_cookie(self, mock_request): """ Test domain cookies without 'Path' """ response0 = Response() response0.status_code = 200 response0._content = 'Mocked response content' response0.headers = { 'Set-Cookie': 'a=apple; Domain=fruits.com;, ' + 'b=banana; Domain=fruits.com;, ' + 'c=citrus; Domain=mediterranean.fruits.com;, ' + 'm=mango; Domain=tropical.fruits.com;' } response0.url = 'http://mediterranean.fruits.com/path0' mock_request.return_value = response0 get('http://mediterranean.fruits.com/path0') # Initial request. No cookies. mock_request.assert_called_with('GET', 'http://mediterranean.fruits.com/path0', allow_redirects=True) get('http://mediterranean.fruits.com/path1') # 'a', 'b', and 'c' cookies should be present. mock_request.assert_called_with('GET', 'http://mediterranean.fruits.com/path1', allow_redirects=True, cookies={'a': 'apple', 'b': 'banana', 'c': 'citrus'}) get('http://tropical.fruits.com/path2') # 'a', 'b', and 'm' cookies should be present. mock_request.assert_called_with('GET', 'http://tropical.fruits.com/path2', allow_redirects=True, cookies={'a': 'apple', 'b': 'banana', 'm': 'mango'}) get('http://www.fruits.com/path3') # 'a' and 'b' cookies should be present. mock_request.assert_called_with('GET', 'http://www.fruits.com/path3', allow_redirects=True, cookies={'a': 'apple', 'b': 'banana'}) get('http://fruits.com/path4') # 'a' and 'b' cookies should be present. mock_request.assert_called_with('GET', 'http://fruits.com/path4', allow_redirects=True, cookies={'a': 'apple', 'b': 'banana'}) get('http://animals.com/path5') # Different domain. No cookies should be present. mock_request.assert_called_with('GET', 'http://animals.com/path5', allow_redirects=True) response1 = Response() response1.status_code = 200 response1._content = 'Mocked response content' response1.headers = { 'Set-Cookie': 'a=apricot; Domain=fruits.com;, ' + 'b=; Domain=fruits.com;, ' + 'm=melon; Domain=tropical.fruits.com;' } response1.url = 'http://tropical.fruits.com/path0' mock_request.return_value = response1 get('http://tropical.fruits.com/path0') # Still called with previous cookies mock_request.assert_called_with('GET', 'http://tropical.fruits.com/path0', allow_redirects=True, cookies={'a': 'apple', 'b': 'banana', 'm': 'mango'}) get('http://tropical.fruits.com/path1') # called with new cookies mock_request.assert_called_with('GET', 'http://tropical.fruits.com/path1', allow_redirects=True, cookies={'a': 'apricot', 'b': '', 'm': 'melon'})
def setUp(self): self.cassette = cassette.Cassette( TestCassette.cassette_name, 'json', 'w+' ) r = Response() r.status_code = 200 r.encoding = 'utf-8' r.headers = CaseInsensitiveDict({'Content-Type': decode('foo')}) r.url = 'http://example.com' cassette.add_urllib3_response({ 'body': { 'string': decode('foo'), 'encoding': 'utf-8' } }, r) self.response = r r = Request() r.method = 'GET' r.url = 'http://example.com' r.headers = {} r.data = {'key': 'value'} self.response.request = r.prepare() self.response.request.headers.update( {'User-Agent': 'betamax/test header'} ) self.json = { 'request': { 'body': 'key=value', 'headers': { 'User-Agent': 'betamax/test header', 'Content-Length': '9', 'Content-Type': 'application/x-www-form-urlencoded', }, 'method': 'GET', 'uri': 'http://example.com/', }, 'response': { 'body': { 'string': decode('foo'), 'encoding': 'utf-8', }, 'headers': {'Content-Type': decode('foo')}, 'status_code': 200, 'url': 'http://example.com', }, 'recorded_at': '2013-08-31T00:00:00', } self.date = datetime(2013, 8, 31) self.cassette.save_interaction(self.response, self.response.request) self.interaction = self.cassette.interactions[0] self.interaction.recorded_at = self.date
def setUp(self): # Make a new serializer to test with self.test_serializer = Serializer() serializers.serializer_registry["test"] = self.test_serializer # Instantiate the cassette to test with self.cassette = cassette.Cassette(TestCassette.cassette_name, "test", record_mode="once") # Create a new object to serialize r = Response() r.status_code = 200 r.reason = "OK" r.encoding = "utf-8" r.headers = CaseInsensitiveDict({"Content-Type": decode("foo")}) r.url = "http://example.com" util.add_urllib3_response({"body": {"string": decode("foo"), "encoding": "utf-8"}}, r) self.response = r # Create an associated request r = Request() r.method = "GET" r.url = "http://example.com" r.headers = {} r.data = {"key": "value"} self.response.request = r.prepare() self.response.request.headers.update({"User-Agent": "betamax/test header"}) # Expected serialized cassette data. self.json = { "request": { "body": {"encoding": "utf-8", "string": "key=value"}, "headers": { "User-Agent": ["betamax/test header"], "Content-Length": ["9"], "Content-Type": ["application/x-www-form-urlencoded"], }, "method": "GET", "uri": "http://example.com/", }, "response": { "body": {"string": decode("foo"), "encoding": "utf-8"}, "headers": {"Content-Type": [decode("foo")]}, "status": {"code": 200, "message": "OK"}, "url": "http://example.com", }, "recorded_at": "2013-08-31T00:00:00", } self.date = datetime(2013, 8, 31) self.cassette.save_interaction(self.response, self.response.request) self.interaction = self.cassette.interactions[0] self.interaction.recorded_at = self.date
def test_redirect(self, mock_request): """ Test that each session has its own redirect "sandbox". """ response0 = Response() response0.url = 'http://www.test.com/neverseemeagain' response0.status_code = 301 response0.headers = {'Location': 'http://www.test.com/redirect_1'} response1 = Response() response1.url = 'http://www.test.com/redirect_1' response1.status_code = 301 response1.headers = {'Location': 'http://www.test.com/redirect_2'} response2 = Response() response2.url = 'http://www.test.com/redirect_2' response2.status_code = 301 response2.headers = {'Location': 'http://www.test.com/redirect_3'} response3 = Response() response3.url = 'http://www.test.com/redirect_3' response3.status_code = 200 response3._content = 'Mocked response content' response3.history = [response0, response1, response2] mock_request.return_value = response3 s0 = Session() s1 = Session() # s0 make a request r = s0.get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/neverseemeagain', allow_redirects=True) self.assertEqual(r.status_code, 200) # s0 make a request again. Assert we not make request to 301 again. r = s0.get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/redirect_3', allow_redirects=True) self.assertEqual(r.status_code, 200) # s1 make a request r = s1.get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/neverseemeagain', allow_redirects=True) self.assertEqual(r.status_code, 200) # s1 make a request again. Assert we not make request to 301 again. r = s1.get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/redirect_3', allow_redirects=True) self.assertEqual(r.status_code, 200)
def requests_call(self, method, url, headers={}, params=None, data=None, stream=False): if (self.MyServerURL == ''): print('no target URL!') return print('request call: ' + method + ' ' + url) headers.update(self.additional_headers) mydata = {} mydata['method'] = method mydata['url'] = url mydata['headers'] = headers mydata['data'] = data mydata['stream'] = stream mydata['params'] = params t = requests.post(self.MyServerURL, None, json.dumps(mydata)) t = json.loads(t.content) final = Response() final.status_code = t['statusCode'] final._content = bytes(t['body'], 'utf-8') final.headers = t['headers'] final.encoding = 'utf-8' tt = mydata return (final)
def test_arn_partition_rewriting_in_response_without_region_and_with_default_region( encoding, switch_region): with switch_region("us-gov-east-1"): listener = ArnPartitionRewriteListener() response = Response() response._content = encoding( json.dumps( {"some-data-with-arn": "arn:aws:iam::123456789012:ArnInData"})) response._status_code = 200 response.headers = { "some-header-with-arn": "arn:aws:iam::123456789012:ArnInHeader" } result = listener.return_response(method="POST", path="/", data="ignored", headers={}, response=response) assert result.status_code == response.status_code assert result.headers == { "some-header-with-arn": "arn:aws-us-gov:iam::123456789012:ArnInHeader" } assert result.content == encoding( json.dumps({ "some-data-with-arn": "arn:aws-us-gov:iam::123456789012:ArnInData" }))
def setup_cache(): response = Response() response.headers = {"ETag": "etag"} response.status_code = 200 _cache["test"] = response yield del _cache._cache["test"]
def create_mock_response(cls, status_code, data, filter=None, order_by=None, page=None, error=None, headers=None): """ Build a fake response Args: status_code: the status code data: the NURESTObject filter: a string representing a filter order_by: a string representing an order by page: a page number """ content = None if type(data) == list: content = list() for obj in data: content.append(obj.to_dict()) elif data: content = data.to_dict() response = Response() response.status_code = status_code response._content = json.dumps(content) if headers: response.headers = headers return MagicMock(return_value=response)
def send(self, request: PreparedRequest, stream=False, timeout=None, verify=True, cert=None, proxies=None): request.url = request.url.decode("utf-8") if isinstance( request.url, bytes) else request.url # Check URL, ask the fake Icinga to handle it self.check_path(request.url) resp = self.icinga.handle(request) # Create response, emulate equests.adapters.HTTPAdapter behavior a bit response = Response() response.status_code = resp.get("status_code", None) response.headers = CaseInsensitiveDict(resp.get("headers", {})) response.encoding = get_encoding_from_headers(response.headers) response.reason = resp.get("reason", None) response.url = request.url # Already decoded above response.request = request response.raw = StreamableBytesIO(resp.get("body", "").encode("utf-8")) # Cookie jar is not mocked, as Icinga doesn't use cookies # response.connection is not mocked, because it's not a response attribute by default # Call settings hook with the settings used for this request (to make testing with these easier) self.settings_hook(stream=stream, timeout=timeout, verify=verify, cert=cert, proxies=proxies) return response
def test_set_default_cookie_cache(self, mock_request): response = Response() response.headers = { 'Set-Cookie': 'name=value', } response.url = 'http://www.test.com/path' mock_request.return_value = response C0 = self.cookie_cache C1 = Cache() C2 = Cache() get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', allow_redirects=True) get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', cookies={'name': 'value'}, allow_redirects=True) set_default_cookie_cache(C1) get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', allow_redirects=True) get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', cookies={'name': 'value'}, allow_redirects=True) set_default_cookie_cache(C2) get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', allow_redirects=True) get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', cookies={'name': 'value'}, allow_redirects=True) set_default_cookie_cache(C0) get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', cookies={'name': 'value'}, allow_redirects=True)
def test_disable_default_cache(self, mock_request): """ Test disable default cache (by setting default cache to None) """ response = Response() response.status_code = 200 response._content = 'Mocked response content' response.headers = { 'Cache-Control': 'max-age=100', } mock_request.return_value = response get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 1) get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 1) set_default_cache(None) get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 2) get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 3) get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 4)
def build_response(self, request, resp): """ Builds a Requests' response object. This emulates most of the logic of the standard fuction but deals with the lack of the ``.headers`` property on the HTTP20Response object. """ response = Response() response.status_code = resp.status response.headers = CaseInsensitiveDict(resp.getheaders()) response.raw = resp response.reason = resp.reason response.encoding = get_encoding_from_headers(response.headers) extract_cookies_to_jar(response.cookies, request, response) response.url = request.url response.request = request response.connection = self # One last horrible patch: Requests expects its raw responses to have a # release_conn method, which I don't. We should monkeypatch a no-op on. resp.release_conn = lambda: None return response
def test_no_arn_partition_rewriting_in_internal_response(): """Partitions should not be rewritten for _responses_ of _internal_ requests.""" listener = ArnPartitionRewriteListener() response = Response() body_content = json.dumps({ "some-data-with-arn": "arn:aws:apigateway:us-gov-west-1::/restapis/arn-in-body/*" }) response._content = body_content response._status_code = 200 response_header_content = { "some-header-with-arn": "arn:aws:apigateway:us-gov-west-1::/restapis/arn-in-header/*" } response.headers = response_header_content # mimic an internal request request_headers = mock_aws_request_headers( region_name="us-gov-west-1", access_key=INTERNAL_AWS_ACCESS_KEY_ID) result = listener.return_response(method="POST", path="/", data="ignored", headers=request_headers, response=response) assert result is None
def send(self, request, stream=None, timeout=None, verify=None, cert=None, proxies=None): parsed_url = urlparse.urlparse(request.url) # We only work for requests with a host of localhost if parsed_url.netloc.lower() != "localhost": raise InvalidURL("Invalid URL %r: Only localhost is allowed" % request.url) real_url = urlparse.urlunparse(parsed_url[:1] + ("",) + parsed_url[2:]) pathname = url_to_path(real_url) resp = Response() resp.status_code = 200 resp.url = real_url stats = os.stat(pathname) modified = email.utils.formatdate(stats.st_mtime, usegmt=True) resp.headers = CaseInsensitiveDict({ "Content-Type": mimetypes.guess_type(pathname)[0] or "text/plain", "Content-Length": stats.st_size, "Last-Modified": modified, }) resp.raw = LocalFSResponse(open(pathname, "rb")) resp.close = resp.raw.close return resp
def requests_response(content, status_code=200, headers={}): resp = RequestsResponse() content = json.dumps(content) if isinstance(content, dict) else content resp._content = content resp.status_code = status_code resp.headers = headers return resp
def send(self, request, stream=None, timeout=None, verify=None, cert=None, proxies=None): pathname = url_to_path(request.url) resp = Response() resp.status_code = 200 resp.url = request.url try: stats = lstat(pathname) except (IOError, OSError) as exc: resp.status_code = 404 message = { "error": "file does not exist", "path": pathname, "exception": repr(exc), } fh = SpooledTemporaryFile() fh.write(ensure_binary(json.dumps(message))) fh.seek(0) resp.raw = fh resp.close = resp.raw.close else: modified = formatdate(stats.st_mtime, usegmt=True) content_type = guess_type(pathname)[0] or "text/plain" resp.headers = CaseInsensitiveDict({ "Content-Type": content_type, "Content-Length": stats.st_size, "Last-Modified": modified, }) resp.raw = open(pathname, "rb") resp.close = resp.raw.close return resp
def build_response(self, req, resp): """Builds a :class:`Response <requests.Response>` object from a urllib3 response. This should not be called from user code, and is only exposed for use when subclassing the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>` :param req: The :class:`PreparedRequest <PreparedRequest>` used to generate the response. :param resp: The urllib3 response object. """ response = Response() # Fallback to None if there's no status_code, for whatever reason. response.status_code = getattr(resp, 'status', None) # Make headers case-insensitive. response.headers = CaseInsensitiveDict(getattr(resp, 'headers', {})) # Set encoding. response.encoding = get_encoding_from_headers(response.headers) response.raw = resp response.reason = response.raw.reason if isinstance(req.url, bytes): response.url = req.url.decode('utf-8') else: response.url = req.url # Add new cookies from the server. extract_cookies_to_jar(response.cookies, req, resp) # Give the Response some context. response.request = req response.connection = self return response
def send(self, request, stream=None, timeout=None, verify=None, cert=None, proxies=None): parsed_url = urlparse.urlparse(request.url) # We only work for requests with a host of localhost if parsed_url.netloc.lower() != "localhost": raise InvalidURL("Invalid URL %r: Only localhost is allowed" % request.url) real_url = urlparse.urlunparse(parsed_url[:1] + ("",) + parsed_url[2:]) pathname = url_to_path(real_url) resp = Response() resp.status_code = 200 resp.url = real_url stats = os.stat(pathname) modified = email.utils.formatdate(stats.st_mtime, usegmt=True) resp.headers = CaseInsensitiveDict({ "Content-Type": mimetypes.guess_type(pathname)[0] or "text/plain", "Content-Length": stats.st_size, "Last-Modified": modified, }) resp.raw = LocalFSResponse(open(pathname, "rb")) resp.close = resp.raw.close return resp
def test_cookie(self, mock_request): """ Test that each session has its own cookie "sandbox". """ response = Response() response.status_code = 200 response._content = 'Mocked response content' response.headers = {'Set-Cookie': 'name=value'} response.url = 'http://www.test.com/path' mock_request.return_value = response s0 = Session() s1 = Session() # s0 make requests s0.get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', allow_redirects=True) s0.get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', allow_redirects=True, cookies={'name': 'value'}) # s1 make requests s1.get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', allow_redirects=True) s1.get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', allow_redirects=True, cookies={'name': 'value'}) # s0 make requests again s0.get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', allow_redirects=True, cookies={'name': 'value'}) s0.get('http://www.test.com/path') mock_request.assert_called_with('GET', 'http://www.test.com/path', allow_redirects=True, cookies={'name': 'value'})
def http_response_to_response(self, http_response, prepared_request): """ transform a WSGIResponse into a requests's Response model :param django.http.response.HttpResponse http_response: the http response send by django view :return: the requests's Response model corresponding to the http_response :rtype: Response """ response = Response() # Fallback to None if there's no status_code, for whatever reason. response.status_code = getattr(http_response, 'status_code', None) # Make headers case-insensitive. response.headers = CaseInsensitiveDict(getattr(http_response._headers, 'headers', {})) # Set encoding. response.encoding = get_encoding_from_headers(response.headers) response.raw = http_response response.reason = response.raw.reason_phrase response._content = http_response.content req = prepared_request if isinstance(req.url, bytes): # pragma: no cover response.url = req.url.decode('utf-8') else: response.url = req.url # Add new cookies from the server. extract_cookies_to_jar(response.cookies, req, response) # Give the Response some context. response.request = req response.connection = self return response
def request(method, url, **kwargs): if 'data' in kwargs: kwargs['params'] = kwargs.pop('data') elif 'params' in kwargs and kwargs['params'] is None: kwargs.pop('params') auth = None if 'auth' in kwargs: auth = kwargs.pop('auth') for i in ['auth', 'allow_redirects', 'stream']: if i in kwargs: kwargs.pop(i) if app.app.registry.api_url in url: if auth: authorization = api.authorization api.authorization = ('Basic', auth) resp = api._gen_request(method.upper(), url, expect_errors=True, **kwargs) if auth: api.authorization = authorization else: resp = app._gen_request(method.upper(), url, expect_errors=True, **kwargs) response = Response() response.status_code = resp.status_int response.headers = CaseInsensitiveDict(getattr(resp, 'headers', {})) response.encoding = get_encoding_from_headers(response.headers) response.raw = resp response._content = resp.body response.reason = resp.status if isinstance(url, bytes): response.url = url.decode('utf-8') else: response.url = url response.request = resp.request return response
async def wrap_async(response: ClientResponse) -> Response: """Build a ``requests`` response from a ``aiohttp`` response. A ``requests.Response`` instance is built to provide synchronous access to the original response's data. Note that the returned response does not have proper data for :attr:``elapsed`` or :attr:``request``. The response will be consumed if it has not already. """ # Ensure the response data is read so that the wrapped response # does not require any async methods. await response.read() wrapped = Response() wrapped._content = response._body # type: ignore wrapped._content_consumed = True # type: ignore wrapped.status_code = response.status wrapped.headers = CaseInsensitiveDict(response.headers) wrapped.url = str(response.url) # `aiohttp` uses a `URL` object. wrapped.encoding = response.get_encoding() wrapped.history = [await wrap_async(rsp) for rsp in response.history] wrapped.reason = response.reason or "" wrapped.cookies = cookiejar_from_dict(response.cookies) return wrapped
def test_arn_partition_rewriting_in_response(encoding): listener = ArnPartitionRewriteListener() response = Response() response._content = encoding( json.dumps( {"some-data-with-arn": "arn:aws:apigateway:us-gov-west-1::/restapis/arn-in-body/*"} ) ) response._status_code = 200 response.headers = { "some-header-with-arn": "arn:aws:apigateway:us-gov-west-1::/restapis/arn-in-header/*" } result = listener.return_response( method="POST", path="/", data="ignored", headers={}, response=response ) assert result.status_code == response.status_code assert result.headers == { "some-header-with-arn": "arn:aws-us-gov:apigateway:us-gov-west-1::/restapis/arn-in-header/*" } assert result.content == encoding( json.dumps( { "some-data-with-arn": "arn:aws-us-gov:apigateway:us-gov-west-1::/restapis/arn-in-body/*" } ) )
def create_mock_response(cls, status_code, data, filter=None, order_by=None, page=None, error=None, headers=None): """ Build a fake response Args: status_code: the status code data: the NURESTObject filter: a string representing a filter order_by: a string representing an order by page: a page number """ content = None if type(data) == list: content = list() for obj in data: content.append(obj.to_dict()) elif data: content = data.to_dict() response = Response() response.status_code = status_code response._content = json.dumps(content).encode('utf-8') if headers: response.headers = headers return MagicMock(return_value=response)
def return_response(self, method, path, data, headers, response): if method == 'POST' and path == '/': req_data = urlparse.parse_qs(data) action = req_data.get('Action', [None])[0] event_type = None if action == 'CreateQueue': event_type = event_publisher.EVENT_SQS_CREATE_QUEUE response_data = xmltodict.parse(response.content) queue_url = response_data['CreateQueueResponse'][ 'CreateQueueResult']['QueueUrl'] elif action == 'DeleteQueue': event_type = event_publisher.EVENT_SQS_DELETE_QUEUE queue_url = req_data.get('QueueUrl', [None])[0] if event_type: event_publisher.fire_event( event_type, payload={'u': event_publisher.get_hash(queue_url)}) # patch the response and return https://... if we're supposed to use SSL if config.USE_SSL and action in ('CreateQueue', 'GetQueueUrl'): content_str = to_str(response.content) if '<QueueUrl>http://' in content_str: new_response = Response() new_response.status_code = response.status_code new_response.headers = response.headers new_response._content = re.sub(r'<QueueUrl>\s*http://', '<QueueUrl>https://', content_str) new_response.headers['content-length'] = len( new_response._content) return new_response
def build_response(self, request, resp): """ Builds a Requests' response object. This emulates most of the logic of the standard fuction but deals with the lack of the ``.headers`` property on the HTTP20Response object. """ response = Response() response.status_code = resp.status response.headers = CaseInsensitiveDict(resp.getheaders()) response.raw = resp response.reason = resp.reason response.encoding = get_encoding_from_headers(response.headers) extract_cookies_to_jar(response.cookies, request, response) if isinstance(request.url, bytes): response.url = request.url.decode('utf-8') else: response.url = request.url response.request = request response.connection = self # One last horrible patch: Requests expects its raw responses to have a # release_conn method, which I don't. We should monkeypatch a no-op on. resp.release_conn = lambda: None return response
def send(self, request, **kwargs): url = urlparse(request.url) if url.scheme != 'https': raise Exception('Only HTTPS is supported!') ctx = self._make_context() conn = httpslib.HTTPSConnection( url.hostname, url.port or 443, ssl_context=ctx) conn.request(request.method, url.path, request.body, request.headers) resp = conn.getresponse() response = Response() # Fallback to None if there's no status_code, for whatever reason. response.status_code = getattr(resp, 'status', None) # Make headers case-insensitive. response.headers = CaseInsensitiveDict(getattr(resp, 'headers', {})) # Set encoding. response.encoding = get_encoding_from_headers(response.headers) response.raw = resp response.reason = response.raw.reason if isinstance(request.url, bytes): response.url = request.url.decode('utf-8') else: response.url = request.url # Give the Response some context. response.request = request response.connection = self return response
def send(self, request, stream=None, timeout=None, verify=None, cert=None, proxies=None): pathname = url_to_path(request.url) resp = Response() resp.status_code = 200 resp.url = request.url try: stats = lstat(pathname) except (IOError, OSError) as exc: resp.status_code = 404 message = { "error": "file does not exist", "path": pathname, "exception": repr(exc), } fh = SpooledTemporaryFile() fh.write(ensure_binary(json.dumps(message))) fh.seek(0) resp.raw = fh resp.close = resp.raw.close else: modified = formatdate(stats.st_mtime, usegmt=True) content_type = guess_type(pathname)[0] or "text/plain" resp.headers = CaseInsensitiveDict({ "Content-Type": content_type, "Content-Length": stats.st_size, "Last-Modified": modified, }) resp.raw = open(pathname, "rb") resp.close = resp.raw.close return resp
def test_expired_cookie(self, mock_request): response = Response() response.status_code = 200 response._content = 'Mocked response content' response.headers = { 'Set-Cookie': 'a=apple; expires=%s;, b=banana; max-age=6' % _getdate(future=3) } response.url = 'http://www.fruits.com' mock_request.return_value = response get('http://www.fruits.com/path') dummycache_cache.datetime.now = lambda: datetime.now() + timedelta(seconds=1) get('http://www.fruits.com/path') mock_request.assert_called_with('GET', 'http://www.fruits.com/path', allow_redirects=True, cookies={'a': 'apple', 'b': 'banana'}) dummycache_cache.datetime.now = lambda: datetime.now() + timedelta(seconds=4) get('http://www.fruits.com/path') mock_request.assert_called_with('GET', 'http://www.fruits.com/path', allow_redirects=True, cookies={'b': 'banana'}) dummycache_cache.datetime.now = lambda: datetime.now() + timedelta(seconds=11) get('http://www.fruits.com/path') mock_request.assert_called_with('GET', 'http://www.fruits.com/path', allow_redirects=True)
def from_serializable(self, data: Any) -> Response: response = Response() for key in self.__response_keys: setattr(response, key, data[key]) for key in self.__response_keys_special: if key == "raw": response.raw = BytesIO(data[key]) if key == "headers": response.headers = CaseInsensitiveDict(data[key]) if key == "elapsed": response.elapsed = datetime.timedelta(seconds=data[key]) if key == "_content": encoding = response.encoding or self.__implicit_encoding indicator = data[self.__store_indicator] if indicator == 0: what_store = data[key] elif indicator == 1: what_store = data[key].encode(encoding) elif indicator == 2: what_store = json.dumps(data[key]) what_store = what_store.encode(encoding) response._content = what_store # type: ignore if key == "_next": setattr(response, "_next", data[key]) return response
def _receive_response(self, task, response): """ Called by the delegate when a response has been received. This call is expected only on background threads, and thus may not do anything that is not Python-thread-safe. This means that, for example, it is safe to grab things from the _tasks dictionary, but it is not safe to make other method calls on this object unless they explicitly state that they are safe in background threads. """ queue, request = self._tasks[task] resp = Response() resp.status_code = getKey(response, 'statusCode') resp.reason = '' # TODO: Why do I have to do this? raw_headers = getKey(response, 'allHeaderFields') resp.headers = CaseInsensitiveDict(raw_headers) resp.encoding = get_encoding_from_headers(resp.headers) # TODO: This needs to point to an object that we can use to provide # the various raw things that requests needs. resp.raw = None if isinstance(request.url, bytes): resp.url = request.url.decode('utf-8') else: resp.url = request.url resp.request = request resp.connection = self # Put this response on the queue. queue.put_nowait(resp)
def return_response(self, method, path, data, headers, response, request_handler): if method == 'OPTIONS' and path == '/': # Allow CORS preflight requests to succeed. return 200 if method != 'POST': return region_name = aws_stack.get_region() req_data = urlparse.parse_qs(to_str(data)) action = req_data.get('Action', [None])[0] content_str = content_str_original = to_str(response.content) if response.status_code >= 400: return response _fire_event(req_data, response) # patch the response and add missing attributes if action == 'GetQueueAttributes': content_str = _add_queue_attributes(path, req_data, content_str, headers) # instruct listeners to fetch new SQS message if action == 'SendMessage': self._process_sent_message(path, data, req_data, headers) # patch the response and return the correct endpoint URLs / ARNs if action in ('CreateQueue', 'GetQueueUrl', 'ListQueues', 'GetQueueAttributes'): if config.USE_SSL and '<QueueUrl>http://' in content_str: # return https://... if we're supposed to use SSL content_str = re.sub(r'<QueueUrl>\s*http://', r'<QueueUrl>https://', content_str) # expose external hostname:port external_port = SQS_PORT_EXTERNAL or get_external_port( headers, request_handler) content_str = re.sub( r'<QueueUrl>\s*([a-z]+)://[^<]*:([0-9]+)/([^<]*)\s*</QueueUrl>', r'<QueueUrl>\1://%s:%s/\3</QueueUrl>' % (HOSTNAME_EXTERNAL, external_port), content_str) # fix queue ARN content_str = re.sub( r'<([a-zA-Z0-9]+)>\s*arn:aws:sqs:elasticmq:([^<]+)</([a-zA-Z0-9]+)>', r'<\1>arn:aws:sqs:%s:\2</\3>' % (region_name), content_str) if action == 'CreateQueue': queue_url = re.match(r'.*<QueueUrl>(.*)</QueueUrl>', content_str, re.DOTALL).group(1) _set_queue_attributes(queue_url, req_data) if content_str_original != content_str: # if changes have been made, return patched response new_response = Response() new_response.status_code = response.status_code new_response.headers = response.headers new_response._content = content_str new_response.headers['content-length'] = len(new_response._content) return new_response
def build_response(self, req, resp): """Builds a :class:`Response <requests.Response>` object from a urllib3 response. This should not be called from user code, and is only exposed for use when subclassing the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>` :param req: The :class:`PreparedRequest <PreparedRequest>` used to generate the response. :param resp: The urllib3 response object. """ response = Response() # Fallback to None if there's no status_code, for whatever reason. response.status_code = getattr(resp, 'status', None) # Make headers case-insensitive. response.headers = CaseInsensitiveDict(getattr(resp, 'headers', {})) # Set encoding. response.encoding = get_encoding_from_headers(response.headers) response.raw = resp response.reason = response.raw.reason if isinstance(req.url, bytes): response.url = req.url.decode('utf-8') else: response.url = req.url # Add new cookies from the server. extract_cookies_to_jar(response.cookies, req, resp) # Give the Response some context. response.request = req response.connection = self return response
def return_response(self, method, path, data, headers, response, request_handler): if method == 'POST' and path == '/': req_data = urlparse.parse_qs(to_str(data)) action = req_data.get('Action', [None])[0] event_type = None queue_url = None if action == 'CreateQueue': event_type = event_publisher.EVENT_SQS_CREATE_QUEUE response_data = xmltodict.parse(response.content) if 'CreateQueueResponse' in response_data: queue_url = response_data['CreateQueueResponse'][ 'CreateQueueResult']['QueueUrl'] elif action == 'DeleteQueue': event_type = event_publisher.EVENT_SQS_DELETE_QUEUE queue_url = req_data.get('QueueUrl', [None])[0] if event_type and queue_url: event_publisher.fire_event( event_type, payload={'u': event_publisher.get_hash(queue_url)}) # patch the response and return the correct endpoint URLs if action in ('CreateQueue', 'GetQueueUrl', 'ListQueues'): content_str = content_str_original = to_str(response.content) new_response = Response() new_response.status_code = response.status_code new_response.headers = response.headers if config.USE_SSL and '<QueueUrl>http://' in content_str: # return https://... if we're supposed to use SSL content_str = re.sub(r'<QueueUrl>\s*http://', r'<QueueUrl>https://', content_str) # expose external hostname:port external_port = get_external_port(headers, request_handler) content_str = re.sub( r'<QueueUrl>\s*([a-z]+)://[^<]*:([0-9]+)/([^<]*)\s*</QueueUrl>', r'<QueueUrl>\1://%s:%s/\3</QueueUrl>' % (HOSTNAME_EXTERNAL, external_port), content_str) new_response._content = content_str if content_str_original != new_response._content: # if changes have been made, return patched response new_response.headers['content-length'] = len( new_response._content) return new_response # Since this API call is not implemented in ElasticMQ, we're mocking it # and letting it return an empty response if action == 'ListQueueTags': new_response = Response() new_response.status_code = 200 new_response._content = ( '<?xml version="1.0"?>' '<ListQueueTagsResponse xmlns="{}">' '<ListQueueTagsResult/>' # noqa: W291 '<ResponseMetadata>' # noqa: W291 '<RequestId>{}</RequestId>' # noqa: W291 '</ResponseMetadata>' # noqa: W291 '</ListQueueTagsResponse>').format(XMLNS_SQS, uuid.uuid4()) return new_response
def test_getting_content_for_empty_2xx_json_response(self, m_get): response = Response() response.status_code = 200 response.headers = {"Content-Type": "application/json"} response._content = str.encode("") m_get.return_value = response response = self.client.get("some_url") assert response == ""
def test_set_default_redirect_cache(self, mock_request): response0 = Response() response0.url = 'http://www.test.com/neverseemeagain' response0.status_code = 301 response0.headers = { 'Location': 'http://www.test.com/redirect_here', } response1 = Response() response1.url = 'http://www.test.com/redirect_here' response1.status_code = 200 response1._content = 'Mocked response content' response1.headers = { 'Vary': 'Accept', } response1.history = [response0] mock_request.return_value = response1 C0 = self.redirect_cache C1 = Cache() C2 = Cache() get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/neverseemeagain', allow_redirects=True) get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/redirect_here', allow_redirects=True) set_default_redirect_cache(C1) get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/neverseemeagain', allow_redirects=True) get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/redirect_here', allow_redirects=True) set_default_redirect_cache(C2) get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/neverseemeagain', allow_redirects=True) get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/redirect_here', allow_redirects=True) set_default_redirect_cache(C0) get('http://www.test.com/neverseemeagain') mock_request.assert_called_with('GET', 'http://www.test.com/redirect_here', allow_redirects=True)
def test_add_urllib3_response(self): r = Response() r.status_code = 200 r.headers = {} util.add_urllib3_response({"body": {"string": decode("foo"), "encoding": "utf-8"}}, r) assert isinstance(r.raw, urllib3.response.HTTPResponse) assert r.content == b"foo" assert isinstance(r.raw._original_response, cassette.MockHTTPResponse)
def deserialize_response(serialized): r = Response() r.encoding = serialized['body']['encoding'] r.headers = CaseInsensitiveDict(serialized['headers']) r.url = serialized.get('url', '') r.status_code = serialized['status_code'] add_urllib3_response(serialized, r) return r
def test_get_etag_missing_header(self): cache = _ResponseCache() response = Response() response.headers = {} cache[self.path] = response out = cache.get_etag(self.path) assert out is None
def send_request(client, endpoint: str, method: str, request_data, request_token: Optional[str] = None): """ Send an api request and return the response. :param client: The requesting client. :param endpoint: The end-point to contact e.g. "/dashboard". :param method: The request method. :param request_data: The data payload. :param request_token: An optional auth token to use instead of the default test token. :return: The status response. """ try: request_data_string = json.dumps(request_data) except ValueError: request_data_string = "" if request_token is None: header = { "X-Auth-Token": testing_api_key } # The token used for testing by default. else: header = {"X-Auth-Token": request_token} if method == "post": response = client.open(endpoint, method="POST", data=request_data_string, content_type="application/json", headers=header) elif method == "get": response = client.open(endpoint, method="GET", data=request_data_string, content_type="application/json", headers=header) elif method == "put": response = client.open(endpoint, method="PUT", data=request_data_string, content_type="application/json", headers=header) elif method == "delete": response = client.open(endpoint, method="DELETE", data=request_data_string, content_type="application/json", headers=header) else: response = Response() response.status_code = 405 response.headers = {"Content-Type": "application/json"} return response
def request(self, *args, **kwargs): res = Response() res.status_code = requests.codes.ok page = self.pages.pop() res.headers = {"link": '<https:///>; rel="next"'} if self.pages else {} res.headers['content-type'] = 'application/json' res.headers['X-OpenAPI-Paginated-Content-Key'] = 'results' res.raw = io.BytesIO(json.dumps(page).encode()) return res
def fake_response(url, html, headers): r = Response() r._content = https_html.encode() r.headers = headers r.url = url return r
def get(self, *args, **kwargs): self.count += 1 resp = Response() resp._content = b'{"results": []}' resp.headers = {"Content-Type": "application/json"} resp.status_code = 200 if (self.fail_first and self.count == 1) or self.fail_all: resp.status_code = 408 return resp
def create_response(data, status_code=200, content_type='application/json'): resp = Response() resp.headers = CaseInsensitiveDict({ 'Content-Type': content_type, }) resp.status_code = status_code resp.raw = data return resp
def send(self, request, **kwargs): response = Response() response.status_code = 200 response.reason = 'OK' response.headers = { 'Content-Type': 'text/html; charset=UTF-8', } response.encoding = get_encoding_from_headers(response.headers) response.raw = BytesIO(b'<!doctype html><html>Hello</html>') return response
def build_response(req, delegate, cookiestore): # type: (PreparedRequest, NSURLSessionAdapterDelegate, NSHTTPCookieStorage) -> Response """Build a requests `Response` object from the response data collected by the NSURLSessionDelegate, and the default cookie store.""" response = Response() # Fallback to None if there's no status_code, for whatever reason. response.status_code = getattr(delegate, 'status', None) # Make headers case-insensitive. response.headers = CaseInsensitiveDict(getattr(delegate, 'headers', {})) # Set encoding. response.encoding = get_encoding_from_headers(response.headers) # response.raw = resp # response.reason = response.raw.reason if isinstance(req.url, bytes): response.url = req.url.decode('utf-8') else: response.url = req.url # Add new cookies from the server. For NSURLSession these have already been parsed. # jar = RequestsCookieJar() # for cookie in cookiestore.cookies(): # print cookie # c = Cookie( # version=cookie.version(), # name=cookie.name(), # value=cookie.value(), # port=8444, # # port=cookie.portList()[-1], # port_specified=0, # domain=cookie.domain(), # domain_specified=cookie.domain(), # domain_initial_dot=cookie.domain(), # path=cookie.path(), # path_specified=cookie.path(), # secure=!cookie.HTTPOnly(), # expires=cookie.expiresDate(), # comment=cookie.comment(), # comment_url=cookie.commentURL(), # ) # jar.set_cookie(c) # # response.cookies = jar response.raw = io.BytesIO(buffer(delegate.output)) # Give the Response some context. response.request = req # response.connection = self return response
def test_cache(self, mock_request): """ Test that each session has its own cache "sandbox". """ response = Response() response.status_code = 200 response._content = 'Mocked response content' response.headers = {'Cache-Control': 'max-age=10'} mock_request.return_value = response s0 = Session() s1 = Session() # T=0: s0 makes multiple requests. Only the 1st request should not come from cache. s0.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 1) s0.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 1) s0.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 1) # T=5: s1 makes multiple requests. Only the 1st request should not come from cache. dummycache_cache.datetime.now = lambda: datetime.now() + timedelta(seconds=5) s1.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 2) s1.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 2) s1.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 2) # s0 makes multiple requests. All requests should come from cache. s0.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 2) s0.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 2) s0.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 2) # T=15: s0 makes multiple requests. Only the 1st request should not come from cache. dummycache_cache.datetime.now = lambda: datetime.now() + timedelta(seconds=15) s0.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 3) s0.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 3) s0.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 3) # s1 makes multiple requests. Only the 1st request should not come from cache. s1.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 4) s1.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 4) s1.get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 4)
def test_get_304(self, mock_request): response0 = Response() response0.status_code = 200 response0._content = 'Mocked response content' response0.headers = { 'Cache-Control': 'max-age=1', 'ETag': '"fdcd6016cf6059cbbf418d66a51a6b0a"', } response1 = Response() response1.status_code = 304 response1._content = '' response1.headers = { 'Cache-Control': 'max-age=2', } mock_request.side_effect = [response0, response1, response1, response1] get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 1) # Move time forward 1 second dummycache_cache.datetime.now = lambda: datetime.now() + timedelta(seconds=1) r = get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 2) self.assertEqual(r.status_code, 304) self.assertEqual(r.content, 'Mocked response content') self.assertEqual(r.headers['Cache-Control'], 'max-age=2') r = get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 2) self.assertEqual(r.status_code, 304) self.assertEqual(r.content, 'Mocked response content') # Move time forward 3 seconds (1 + 2) dummycache_cache.datetime.now = lambda: datetime.now() + timedelta(seconds=3) r = get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 3) self.assertEqual(r.status_code, 304) self.assertEqual(r.content, 'Mocked response content') self.assertEqual(r.headers['Cache-Control'], 'max-age=2')
def test_decoding_content_for_2xx_json_response(self, m_get): response = Response() response.status_code = 200 response.headers = {"Content-Type": "application/json"} response._content = str.encode( json.dumps( {"data": "this_is_some_content_string_that_needs_to_be_long"})) m_get.return_value = response response = self.client.get("some_url") assert response[ "data"] == "this_is_some_content_string_that_needs_to_be_long"
def test_get_response_headers_response(self): """Test we get expected headers with a Response argument.""" proxy_response = Response() proxy_response.headers = {'lol': 'wat', 'etag': '1'} with webcompat.app.app_context(): new_headers = get_response_headers(proxy_response) assert new_headers.get('content-type') == 'application/json' assert new_headers.get('etag') == '1' assert new_headers.get('lol') is None new_headers2 = get_response_headers(proxy_response, mime_type='text/html') assert new_headers2.get('content-type') == 'text/html'
def return_response(self, method, path, data, headers, response): req_data = None if method == 'POST' and path == '/': req_data = urlparse.parse_qs(to_str(data)) action = req_data.get('Action')[0] if req_data: if action == 'DescribeStackResources': if response.status_code < 300: response_dict = xmltodict.parse(response.content)['DescribeStackResourcesResponse'] resources = response_dict['DescribeStackResourcesResult']['StackResources'] if not resources: # Check if stack exists stack_name = req_data.get('StackName')[0] cloudformation_client = aws_stack.connect_to_service('cloudformation') try: cloudformation_client.describe_stacks(StackName=stack_name) except Exception: return error_response('Stack with id %s does not exist' % stack_name, code=404) if action == 'DescribeStackResource': if response.status_code >= 500: # fix an error in moto where it fails with 500 if the stack does not exist return error_response('Stack resource does not exist', code=404) if action == 'ListStackResources': response_dict = xmltodict.parse(response.content, force_list=('member'))['ListStackResourcesResponse'] resources = response_dict['ListStackResourcesResult']['StackResourceSummaries'] if resources: sqs_client = aws_stack.connect_to_service('sqs') content_str = content_str_original = to_str(response.content) new_response = Response() new_response.status_code = response.status_code new_response.headers = response.headers for resource in resources['member']: if resource['ResourceType'] == 'AWS::SQS::Queue': try: queue_name = resource['PhysicalResourceId'] queue_url = sqs_client.get_queue_url(QueueName=queue_name)['QueueUrl'] except Exception: stack_name = req_data.get('StackName')[0] return error_response('Stack with id %s does not exist' % stack_name, code=404) content_str = re.sub(resource['PhysicalResourceId'], queue_url, content_str) new_response._content = content_str if content_str_original != new_response._content: # if changes have been made, return patched response new_response.headers['content-length'] = len(new_response._content) return new_response elif action in ('CreateStack', 'UpdateStack'): if response.status_code >= 400: return response # run the actual deployment template = template_deployer.template_to_json(req_data.get('TemplateBody')[0]) template_deployer.deploy_template(template, req_data.get('StackName')[0])
def test_add_urllib3_response(self): r = Response() r.status_code = 200 r.headers = {} cassette.add_urllib3_response({ 'body': { 'string': decode('foo'), 'encoding': 'utf-8' } }, r) assert isinstance(r.raw, urllib3.response.HTTPResponse) assert r.content == b'foo' assert isinstance(r.raw._original_response, cassette.MockHTTPResponse)
def test_get_304_cache_not_exist(self, mock_request): response0 = Response() response0.status_code = 200 response0._content = 'Mocked response content X' response0.headers = { 'Cache-Control': 'max-age=10', 'ETag': '"fdcd6016cf6059cbbf418d66a51a6b0a"', } response1 = Response() response1.status_code = 304 response1._content = '' response1.headers = { 'Cache-Control': 'max-age=10', } response2 = Response() response2.status_code = 200 response2._content = 'Mocked response content Y' response2.headers = { 'Cache-Control': 'max-age=10', 'ETag': '"a0b6a15a66d814fbbc9506fc6106dcdf"', } mock_request.side_effect = [response0, response1, response2] r = get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 1) self.assertEqual(r.content, 'Mocked response content X') self.cache.clear() r = get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 3) self.assertEqual(r.content, 'Mocked response content Y') r = get('http://www.test.com/path') self.assertEqual(mock_request.call_count, 3) self.assertEqual(r.content, 'Mocked response content Y')
def side_effect(url, *args, **kwargs): if '/1' in url: response = Response() response.status_code = 200 response._content = 'Mocked response content X' response.headers = { 'Cache-Control': 'max-age=1', 'ETag': '"fdcd6016cf6059cbbf418d66a51a6b0a"', } elif '/2' in url: response = Response() response.status_code = 204 response._content = 'Mocked response content Y' response.headers = { 'Cache-Control': 'max-age=1', 'ETag': '"ffffffffffffffffffffffffffffffff"', } else: response = Response() response.status_code = 403 response._content = 'Mocked response content Z' return response
def test_origin_cookies_with_max_age(self): """ Test setting and getting origin cookies with 'Max-Age' and/or 'Expires' attribute """ # Cookie cache keys for convenience lookup_key = self.cookie_manager.get_origin_cookie_lookup_key("sweet.test.com") chipsahoy_key = self.cookie_manager.get_origin_cookie_key("sweet.test.com", "", "chipsahoy") coke_key = self.cookie_manager.get_origin_cookie_key("sweet.test.com", "", "coke") squeeze_key = self.cookie_manager.get_origin_cookie_key("sweet.test.com", "", "squeeze") kitkat_key = self.cookie_manager.get_origin_cookie_key("sweet.test.com", "", "kitkat") # Prepare test responses response0 = Response() response0.headers = { "Set-Cookie": "chipsahoy=cookie; Max-Age=3;, " + "coke=soda; Max-Age=6;, " + "squeeze=juice; Expires=%s;, " % _getdate(future=3) + "kitkat=chocolate;" } response0.url = "http://sweet.test.com/path" ##### Process response cookie #### self.cookie_manager.process_response(None, response0) # Note that 'request' is not used (thus None param) ##### Process request ##### request = Request("http://sweet.test.com/help") self.cookie_manager.process_request(request) self.assertEqual( request.cookies, {"chipsahoy": "cookie", "coke": "soda", "squeeze": "juice", "kitkat": "chocolate"} ) cookie_keys_set = self.cookie_cache.get(lookup_key) self.assertEqual(cookie_keys_set, set([chipsahoy_key, coke_key, squeeze_key, kitkat_key])) # 3 seconds pass by dummycache_cache.datetime.now = lambda: datetime.now() + timedelta(seconds=3) request = Request("http://sweet.test.com/help") self.cookie_manager.process_request(request) self.assertEqual(request.cookies, {"coke": "soda", "kitkat": "chocolate"}) cookie_keys_set = self.cookie_cache.get(lookup_key) self.assertEqual(cookie_keys_set, set([coke_key, kitkat_key])) # 3 more seconds pass by dummycache_cache.datetime.now = lambda: datetime.now() + timedelta(seconds=6) request = Request("http://sweet.test.com/help") self.cookie_manager.process_request(request) self.assertEqual(request.cookies, {"kitkat": "chocolate"}) cookie_keys_set = self.cookie_cache.get(lookup_key) self.assertEqual(cookie_keys_set, set([kitkat_key]))