def test_find(self):
mock_request_1 = self._create_mock_request(
'http://www.example.com/test/path/?foo=bar')
mock_request_2 = self._create_mock_request(
'http://www.stackoverflow.com/other/path/?x=y')
mock_response = self._create_mock_resonse()
storage = RequestStorage(base_dir=self.base_dir)
request_id = storage.save_request(mock_request_1)
storage.save_response(request_id, mock_response)
storage.save_request(mock_request_2)
self.assertEqual(storage.find('/test/path/')['id'], request_id)
self.assertEqual(storage.find('/test/path/?foo=bar')['id'], request_id)
self.assertEqual(
storage.find('http://www.example.com/test/path/?foo=bar')['id'],
request_id)
self.assertEqual(
storage.find('http://www.example.com/test/path/')['id'],
request_id)
self.assertIsNone(storage.find('/different/path'))
self.assertIsNone(storage.find('/test/path/?x=y'))
self.assertIsNone(
storage.find('http://www.example.com/different/path/?foo=bar'))
self.assertIsNone(
storage.find('http://www.different.com/test/path/?foo=bar'))
self.assertIsNone(
storage.find('http://www.example.com/test/path/?x=y'))
def test_load_request_body(self):
body = b'test request body'
request = self._create_request(body=body)
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request)
request_body = storage.load_request_body(request.id)
self.assertEqual(body, request_body)
def test_load_last_request(self):
request_1 = self._create_request()
request_2 = self._create_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request_1)
storage.save_request(request_2)
last_request = storage.load_last_request()
self.assertEqual(request_2.id, last_request.id)
def test_load_response(self):
request = self._create_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request)
response = self._create_response()
storage.save_response(request.id, response)
requests = storage.load_requests()
self.assertIsNotNone(requests[0].response)
def test_load_last_request(self):
mock_request_1 = self._create_mock_request()
mock_request_2 = self._create_mock_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(mock_request_1)
request_id2 = storage.save_request(mock_request_2)
last_request = storage.load_last_request()
self.assertEqual(last_request['id'], request_id2)
def test_load_response_body(self):
body = b'test response body'
request = self._create_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request)
mock_response = self._create_response(body=body)
storage.save_response(request.id, mock_response)
response_body = storage.load_response_body(request.id)
self.assertEqual(body, response_body)
def test_load_response_encoded_body_error(self):
body = b'test response body'
request = self._create_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request)
response = self._create_response(body=body)
response.headers['Content-Encoding'] = 'gzip'
storage.save_response(request.id, response)
response_body = storage.load_requests()[0].response.body
self.assertEqual(body, response_body)
def test_save_response_no_request(self):
request = self._create_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request)
response = self._create_response()
storage.clear_requests()
storage.save_response(request.id, response)
response_file_path = self._get_stored_path(request.id, 'response')
self.assertFalse(response_file_path)
def test_clear_requests(self):
mock_request_1 = self._create_mock_request()
mock_request_2 = self._create_mock_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(mock_request_1)
storage.save_request(mock_request_2)
storage.clear_requests()
requests = storage.load_requests()
self.assertFalse(requests)
self.assertFalse(glob.glob(os.path.join(self.base_dir, '.seleniumwire', 'storage-*', '*')))
def test_save_request_with_body(self):
body = b'test request body'
request = self._create_request(body=body)
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request)
request_file_path = self._get_stored_path(request.id, 'request')
with open(request_file_path[0], 'rb') as loaded:
loaded_request = pickle.load(loaded)
self.assertEqual(body, loaded_request.body)
def test_find_similar_urls(self):
request_1 = self._create_request('https://192.168.1.1/redfish/v1')
request_2 = self._create_request('https://192.168.1.1/redfish')
mock_response = self._create_response()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request_1)
storage.save_response(request_1.id, mock_response)
storage.save_request(request_2)
storage.save_response(request_2.id, mock_response)
self.assertEqual(request_1.id, storage.find('.*v1').id)
self.assertEqual(request_2.id,
storage.find('https://192.168.1.1/redfish$').id)
def test_load_requests(self):
request_1 = self._create_request()
request_2 = self._create_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request_1)
storage.save_request(request_2)
requests = storage.load_requests()
self.assertEqual(2, len(requests))
self.assertEqual(request_1.id, requests[0].id)
self.assertEqual(request_2.id, requests[1].id)
self.assertIsNone(requests[0].response)
self.assertIsNone(requests[1].response)
def test_save_response_with_body(self):
body = b'some response body'
request = self._create_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request)
response = self._create_response(body=body)
storage.save_response(request.id, response)
response_file_path = self._get_stored_path(request.id, 'response')
with open(response_file_path[0], 'rb') as loaded:
loaded_response = pickle.load(loaded)
self.assertEqual(b'some response body', loaded_response.body)
def test_load_response_encoded_body(self):
body = b'test response body'
io = BytesIO()
with gzip.GzipFile(fileobj=io, mode='wb') as f:
f.write(body)
request = self._create_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request)
response = self._create_response(body=io.getvalue())
response.headers['Content-Encoding'] = 'gzip'
storage.save_response(request.id, response)
response_body = storage.load_requests()[0].response.body
self.assertEqual(body, response_body)
def test_load_request_body(self):
mock_request = self._create_mock_request()
storage = RequestStorage(base_dir=self.base_dir)
request_id = storage.save_request(mock_request, request_body=b'test request body')
request_body = storage.load_request_body(request_id)
self.assertEqual(request_body, b'test request body')
def test_load_response(self):
mock_request = self._create_mock_request()
storage = RequestStorage(base_dir=self.base_dir)
request_id = storage.save_request(mock_request)
mock_response = self._create_mock_resonse()
storage.save_response(request_id, mock_response)
requests = storage.load_requests()
self.assertIsNotNone(requests[0]['response'])
def test_save_response(self):
request = self._create_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request)
response = self._create_response()
storage.save_response(request.id, response)
response_file_path = self._get_stored_path(request.id, 'response')
with open(response_file_path[0], 'rb') as loaded:
loaded_response = pickle.load(loaded)
self.assertEqual(200, loaded_response.status_code)
self.assertEqual('OK', loaded_response.reason)
self.assertEqual(
{
'Content-Type': 'application/json',
'Content-Length': '500'
}, dict(loaded_response.headers))
def test_save_request(self):
request = self._create_request()
storage = RequestStorage(base_dir=self.base_dir)
storage.save_request(request)
request_file_path = self._get_stored_path(request.id, 'request')
with open(request_file_path[0], 'rb') as loaded:
loaded_request = pickle.load(loaded)
self.assertEqual(request.id, loaded_request.id)
self.assertEqual('http://www.example.com/test/path/',
loaded_request.url)
self.assertEqual('GET', loaded_request.method)
self.assertEqual({
'Host': 'www.example.com',
'Accept': '*/*'
}, dict(loaded_request.headers))
self.assertIsNone(loaded_request.response)
def test_save_request_with_body(self):
mock_request = self._create_mock_request()
request_body = b'test request body'
storage = RequestStorage(base_dir=self.base_dir)
request_id = storage.save_request(mock_request, request_body=request_body)
request_body_path = self._get_stored_path(request_id, 'requestbody')
with open(request_body_path[0], 'rb') as loaded:
loaded_body = pickle.load(loaded)
self.assertEqual(loaded_body, b'test request body')
def test_load_requests(self):
mock_request_1 = self._create_mock_request()
mock_request_2 = self._create_mock_request()
storage = RequestStorage(base_dir=self.base_dir)
request_id1 = storage.save_request(mock_request_1)
request_id2 = storage.save_request(mock_request_2)
requests = storage.load_requests()
self.assertEqual(len(requests), 2)
self.assertEqual(requests[0]['id'], request_id1)
self.assertEqual(requests[1]['id'], request_id2)
self.assertIsNone(requests[0]['response'])
self.assertIsNone(requests[1]['response'])
def test_load_response_body_encoded(self):
io = BytesIO()
with gzip.GzipFile(fileobj=io, mode='wb') as f:
f.write(b'test response body')
mock_request = self._create_mock_request()
storage = RequestStorage(base_dir=self.base_dir)
request_id = storage.save_request(mock_request, request_body=b'test request body')
mock_response = self._create_mock_resonse()
mock_response.headers['Content-Encoding'] = 'gzip'
storage.save_response(request_id, mock_response, response_body=io.getvalue())
response_body = storage.load_response_body(request_id)
self.assertEqual(response_body, b'test response body')
def test_save_response(self):
mock_request = self._create_mock_request()
storage = RequestStorage(base_dir=self.base_dir)
request_id = storage.save_request(mock_request)
mock_response = self._create_mock_resonse()
storage.save_response(request_id, mock_response)
response_file_path = self._get_stored_path(request_id, 'response')
with open(response_file_path[0], 'rb') as loaded:
loaded_response = pickle.load(loaded)
self.assertEqual(loaded_response['status_code'], 200)
self.assertEqual(loaded_response['reason'], 'OK')
self.assertEqual(loaded_response['headers'], {
'Content-Type': 'application/json',
'Content-Length': '500'
})
def test_save_request(self):
mock_request = self._create_mock_request()
storage = RequestStorage(base_dir=self.base_dir)
request_id = storage.save_request(mock_request)
request_file_path = self._get_stored_path(request_id, 'request')
with open(request_file_path[0], 'rb') as loaded:
loaded_request = pickle.load(loaded)
self.assertEqual(loaded_request['id'], request_id)
self.assertEqual(loaded_request['path'], 'http://www.example.com/test/path/')
self.assertEqual(loaded_request['method'], 'GET')
self.assertEqual(loaded_request['headers'], {
'Host': 'www.example.com',
'Accept': '*/*'
})
self.assertIsNone(loaded_request['response'])