def serialize_response(response, preserve_exact_body_bytes): body = {'encoding': response.encoding} add_body(response, preserve_exact_body_bytes, body) header_map = HTTPHeaderDict(response.raw.headers) headers = {} for header_name in header_map.keys(): headers[header_name] = header_map.getlist(header_name) return { 'body': body, 'headers': headers, 'status': {'code': response.status_code, 'message': response.reason}, 'url': response.url, }
def serialize_response(response, preserve_exact_body_bytes): body = {'encoding': response.encoding} add_body(response, preserve_exact_body_bytes, body) header_map = HTTPHeaderDict(response.raw.headers) headers = {} for header_name in header_map.keys(): headers[header_name] = header_map.getlist(header_name) return { 'body': body, 'headers': headers, 'status': { 'code': response.status_code, 'message': response.reason }, 'url': response.url, }
def route_to_testapp(self, url, requests_req): '''This is some tricky stuff. To test the client methods, we need the responses package calls to route to our webtest TestApp WSGI wrapper. We use httmock to intercept the requests call, then we handle processing in this function instead -- calling the TestApp wrapper. ''' if url.geturl() != requests_req.url: logging.warn('%s != %s', url.geturl(), requests_req.url) # create a webtest TestRequest from the requests PreparedRequest webtest_req = TestRequest.blank(requests_req.url, method=requests_req.method, body=requests_req.body, headers=requests_req.headers) # have the TestApp wrapper process the TestRequest webtest_resp = self.tasr.request(webtest_req) '''webtest responses support multiple headers with the same key, while the requests package holds them in a case-insensitive dict of lists of (key,value) tuples. We need to translate by hand here to keep cases with multiple headers with the same key ''' headers = HTTPHeaderDict() for key, value in webtest_resp.headers.iteritems(): headers.add(key, value) # use the webtest TestResponse to build a new requests HTTPResponse requests_http_resp = HTTPResponse(body=webtest_resp.body, headers=headers, status=webtest_resp.status_code) # get an HTTPAdaptor, then use it to build the requests Response object adap = requests.adapters.HTTPAdapter() requests_resp = adap.build_response(requests_req, requests_http_resp) '''For some reason, we need to explicitly set the _content attribute after the response object is built -- it is already in there as raw.data, but it doesn't make it to _content, so it never hits content() without this intervention. ''' requests_resp._content = webtest_resp.body return requests_resp
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, HTTPHeaderDict()) 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'] header_dict = HTTPHeaderDict() for header_name, header_list in serialized['headers'].items(): if isinstance(header_list, list): for header_value in header_list: header_dict.add(header_name, header_value) else: header_dict.add(header_name, header_list) r.headers = CaseInsensitiveDict(header_dict) r.url = serialized.get('url', '') if 'status' in serialized: r.status_code = serialized['status']['code'] r.reason = serialized['status']['message'] else: r.status_code = serialized['status_code'] r.reason = _codes[r.status_code][0].upper() add_urllib3_response(serialized, r, header_dict) return r
def test_serialize_response(self): r = Response() r.status_code = 200 r.reason = 'OK' r.encoding = 'utf-8' r.headers = CaseInsensitiveDict() r.url = 'http://example.com' util.add_urllib3_response( {'body': { 'string': decode('foo'), 'encoding': 'utf-8' }}, r, HTTPHeaderDict()) serialized = util.serialize_response(r, False) assert serialized is not None assert serialized != {} assert serialized['body']['encoding'] == 'utf-8' assert serialized['body']['string'] == 'foo' assert serialized['headers'] == {} assert serialized['url'] == 'http://example.com' assert serialized['status'] == {'code': 200, 'message': 'OK'}
def deserialize_response(serialized): r = Response() r.encoding = serialized['body']['encoding'] header_dict = HTTPHeaderDict() for header_name, header_list in serialized['headers'].items(): if isinstance(header_list, list): for header_value in header_list: header_dict.add(header_name, header_value) else: header_dict.add(header_name, header_list) r.headers = CaseInsensitiveDict(header_dict) r.url = serialized.get('url', '') if 'status' in serialized: r.status_code = serialized['status']['code'] r.reason = serialized['status']['message'] else: r.status_code = serialized['status_code'] r.reason = _codes[r.status_code][0].upper() add_urllib3_response(serialized, r, header_dict) return r
def setUp(self): self.resp = mock_response.MockHTTPResponse( HTTPHeaderDict({decode('Header'): decode('value')}))
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, HTTPHeaderDict({'Content-Type': decode('foo')})) 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]
def test_pre_record_hook_v2(self): fixtures_path = 'keystoneauth1/tests/unit/data' with betamax.Betamax.configure() as config: config.before_record(callback=hooks.pre_record_hook) cassette = betamax.cassette.Cassette( 'test_pre_record_hook', 'json', record_mode=None, cassette_library_dir=fixtures_path) # Create a new object to serialize r = models.Response() r.status_code = 200 r.reason = 'OK' r.encoding = 'utf-8' r.headers = {} r.url = 'http://localhost:35357/' # load request and response with open('%s/keystone_v2_sample_response.json' % fixtures_path) as f: response_content = json.loads(f.read()) with open('%s/keystone_v2_sample_request.json' % fixtures_path) as f: request_content = json.loads(f.read()) body_content = { 'body': { 'string': json.dumps(response_content), 'encoding': 'utf-8', } } betamax.util.add_urllib3_response( body_content, r, HTTPHeaderDict({'Accept': 'application/json'})) response = r # Create an associated request r = models.Request() r.method = 'GET' r.url = 'http://localhost:35357/' r.headers = {} r.data = {} response.request = r.prepare() response.request.headers.update({'User-Agent': 'betamax/test header'}) response.request.body = json.dumps(request_content) interaction = cassette.save_interaction(response, response.request) # check that all values have been masked response_content = json.loads( interaction.data['response']['body']['string']) self.assertEqual(response_content['access']['token']['expires'], u'9999-12-31T23:59:59Z') self.assertEqual(response_content['access']['token']['tenant']['name'], u'dummy') self.assertEqual(response_content['access']['user']['name'], u'dummy') request_content = json.loads( interaction.data['request']['body']['string']) self.assertEqual( request_content['auth']['passwordCredentials']['password'], u'********') self.assertEqual( request_content['auth']['passwordCredentials']['username'], u'dummy') self.assertEqual(request_content['auth']['tenantName'], u'dummy')
def _set_raw(self): utils.add_urllib3_response( {'body': { 'string': self.html, 'encoding': 'utf-8' }}, self, HTTPHeaderDict(self.headers))