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 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 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))
