def test_customized_path_raw_request(self): """ Verify the customized path being used for HTTP requests reflects accurately """ def check_request(method, path, **kwargs): self.assertEqual('GET', method) self.assertEqual('/customized-path/v1/images/detail', path) # NOTE(yuyangbj): see bug 1230032 to get more info endpoint = 'http://example.com:9292/customized-path' client = http.HTTPClient(endpoint, token=u'abc123') self.assertEqual('/customized-path', client.endpoint_path) http_client.HTTPConnection.request( mox.IgnoreArg(), mox.IgnoreArg(), headers=mox.IgnoreArg()).WithSideEffects(check_request) # fake the response returned by httplib fake = utils.FakeResponse({}, six.BytesIO(b'Ok')) http_client.HTTPConnection.getresponse().AndReturn(fake) self.mock.ReplayAll() resp, body = client.raw_request('GET', '/v1/images/detail') self.assertEqual(fake, resp)
def test_set_checksum_in_consumed_iterator(self): resp = utils.FakeResponse({}, six.BytesIO(b'CCC')) body = http.ResponseBodyIterator(resp) list(body) # Setting checksum for an already consumed iterator should raise an # AttributeError. self.assertRaises(AttributeError, body.set_checksum, 'defb99e69a9f1f6e06f15006b1f166ae')
def test_log_http_response_with_non_ascii_char(self): try: response = 'Ok' headers = {"Content-Type": "text/plain", "test": "value1\xa5\xa6"} fake = utils.FakeResponse(headers, six.StringIO(response)) self.client.log_http_response(fake) except UnicodeDecodeError as e: self.fail("Unexpected UnicodeDecodeError exception '%s'" % e)
def test_integrity_check_with_wrong_checksum(self): resp = utils.FakeResponse({}, six.BytesIO(b'BB')) body = http.ResponseBodyIterator(resp) body.set_checksum('wrong') try: list(body) self.fail('integrity checked passed with wrong checksum') except IOError as e: self.assertEqual(errno.EPIPE, e.errno)
def test_log_http_response_with_non_ascii_char(self): if not hasattr(self.client, 'log_http_response'): self.skipTest('Cannot do log checking on SessionClient') try: response = 'Ok' headers = {"Content-Type": "text/plain", "test": "value1\xa5\xa6"} fake = utils.FakeResponse(headers, six.StringIO(response)) self.client.log_http_response(fake) except UnicodeDecodeError as e: self.fail("Unexpected UnicodeDecodeError exception '%s'" % e)
def test_raw_request(self): " Verify the path being used for HTTP requests reflects accurately. " headers = {"Content-Type": "text/plain"} response = 'Ok' fake = utils.FakeResponse({}, six.StringIO(response)) requests.Session.request(mox.IgnoreArg(), mox.IgnoreArg(), data=mox.IgnoreArg(), stream=mox.IgnoreArg(), headers=mox.IgnoreArg()).AndReturn(fake) self.mock.ReplayAll() resp, body = self.client.get('/v1/images/detail', headers=headers) self.assertEqual(fake, resp)
def test_image_download(self): args = self._make_args({ 'id': 'pass', 'file': 'test', 'progress': False }) with mock.patch.object(self.gc.images, 'data') as mocked_data: resp = test_utils.FakeResponse({}, StringIO.StringIO('CCC')) ret = mocked_data.return_value = http.ResponseBodyIterator(resp) test_shell.do_image_download(self.gc, args) mocked_data.assert_called_once_with('pass') utils.save_image.assert_called_once_with(ret, 'test')
def test_http_chunked_response(self): headers = {"Content-Type": "application/octet-stream"} data = "TEST" fake = utils.FakeResponse(headers, six.StringIO(data)) requests.Session.request(mox.IgnoreArg(), mox.IgnoreArg(), stream=mox.IgnoreArg(), data=mox.IgnoreArg(), headers=mox.IgnoreArg()).AndReturn(fake) self.mock.ReplayAll() headers = {"test": u'chunked_request'} resp, body = self.client.get('/v1/images/') self.assertTrue(isinstance(body, types.GeneratorType)) self.assertEqual([data], list(body))
def test_request_redirected(self): resp = utils.FakeResponse({'location': 'http://www.example.com'}, status=302, body=six.BytesIO()) http_client.HTTPConnection.request( mox.IgnoreArg(), mox.IgnoreArg(), headers=mox.IgnoreArg(), ) http_client.HTTPConnection.getresponse().AndReturn(resp) # The second request should be to the redirected location expected_response = b'Ok' resp2 = utils.FakeResponse({}, six.BytesIO(expected_response)) http_client.HTTPConnection.request( 'GET', 'http://www.example.com', headers=mox.IgnoreArg(), ) http_client.HTTPConnection.getresponse().AndReturn(resp2) self.mock.ReplayAll() self.client.json_request('GET', '/v1/images/detail')
def test_image_download_with_progressbar(self): args = self._make_args({ 'id': 'pass', 'file': 'test', 'progress': True }) with mock.patch.object(self.gc.images, 'data') as mocked_data: resp = test_utils.FakeResponse({}, StringIO.StringIO('CCC')) mocked_data.return_value = http.ResponseBodyIterator(resp) test_shell.do_image_download(self.gc, args) mocked_data.assert_called_once_with('pass') utils.save_image.assert_called_once_with(mock.ANY, 'test') self.assertIsInstance(utils.save_image.call_args[0][0], progressbar.VerboseIteratorWrapper)
def test_http_encoding(self): # Lets fake the response # returned by requests response = 'Ok' headers = {"Content-Type": "text/plain"} fake = utils.FakeResponse(headers, six.StringIO(response)) requests.Session.request(mox.IgnoreArg(), mox.IgnoreArg(), data=mox.IgnoreArg(), stream=mox.IgnoreArg(), headers=mox.IgnoreArg()).AndReturn(fake) self.mock.ReplayAll() headers = {"test": u'ni\xf1o'} resp, body = self.client.get('/v1/images/detail', headers=headers) self.assertEqual(fake, resp)
def test_http_encoding(self): httplib.HTTPConnection.request(mox.IgnoreArg(), mox.IgnoreArg(), headers=mox.IgnoreArg()) # Lets fake the response # returned by httplib expected_response = 'Ok' fake = utils.FakeResponse({}, StringIO.StringIO(expected_response)) httplib.HTTPConnection.getresponse().AndReturn(fake) self.mock.ReplayAll() headers = {"test": u'ni\xf1o'} resp, body = self.client.raw_request('GET', '/v1/images/detail', headers=headers) self.assertEqual(resp, fake)
def test_http_chunked_request(self): # Lets fake the response # returned by requests response = "Ok" data = six.StringIO(response) fake = utils.FakeResponse({}, data) requests.Session.request(mox.IgnoreArg(), mox.IgnoreArg(), stream=mox.IgnoreArg(), data=mox.IsA(types.GeneratorType), headers=mox.IgnoreArg()).AndReturn(fake) self.mock.ReplayAll() headers = {"test": u'chunked_request'} resp, body = self.client.post('/v1/images/', headers=headers, data=data) self.assertEqual(fake, resp)
def test_raw_request(self): " Verify the path being used for HTTP requests reflects accurately. " def check_request(method, path, **kwargs): self.assertEqual(method, 'GET') # NOTE(kmcdonald): See bug #1179984 for more details. self.assertEqual(path, '/v1/images/detail') httplib.HTTPConnection.request( mox.IgnoreArg(), mox.IgnoreArg(), headers=mox.IgnoreArg()).WithSideEffects(check_request) # fake the response returned by httplib fake = utils.FakeResponse({}, StringIO.StringIO('Ok')) httplib.HTTPConnection.getresponse().AndReturn(fake) self.mock.ReplayAll() resp, body = self.client.raw_request('GET', '/v1/images/detail') self.assertEqual(resp, fake)
def test_http_json(self): data = {"test": "json_request"} fake = utils.FakeResponse({}, b"OK") def test_json(passed_data): """ This function tests whether the data being passed to request's method is a valid json or not. This function will be called by pymox :params passed_data: The data being passed to requests.Session.request. """ if not isinstance(passed_data, six.string_types): return False try: passed_data = json.loads(passed_data) return data == passed_data except (TypeError, ValueError): return False requests.Session.request(mox.IgnoreArg(), mox.IgnoreArg(), stream=mox.IgnoreArg(), data=mox.Func(test_json), headers=mox.IgnoreArg()).AndReturn(fake) self.mock.ReplayAll() headers = {"test": u'chunked_request'} resp, body = self.client.post('/v1/images/', headers=headers, data=data) self.assertEqual(fake, resp)
def test_iter_default_chunk_size_64k(self): resp = utils.FakeResponse({}, six.BytesIO(b'X' * 98304)) iterator = http.ResponseBodyIterator(resp) chunks = list(iterator) self.assertEqual([b'X' * 65536, b'X' * 32768], chunks)
def check_headers(*args, **kwargs): headers = kwargs.get('headers') for k, v in six.iteritems(identity_headers): self.assertEqual(v, headers[k]) return utils.FakeResponse({}, six.StringIO('{}'))
def test_iter_default_chunk_size_64k(self): resp = utils.FakeResponse({}, StringIO.StringIO('X' * 98304)) iterator = http.ResponseBodyIterator(resp) chunks = list(iterator) self.assertEqual(chunks, ['X' * 65536, 'X' * 32768])
def get(self, url, **kwargs): self.url = url return utils.FakeResponse({}), ParameterFakeAPI.image_list
def test_integrity_check_with_correct_checksum(self): resp = utils.FakeResponse({}, six.BytesIO(b'CCC')) body = http.ResponseBodyIterator(resp) body.set_checksum('defb99e69a9f1f6e06f15006b1f166ae') list(body)
def test_body_size(self): size = 1000000007 resp = utils.FakeResponse({'content-length': str(size)}, six.BytesIO(b'BB')) body = http.ResponseBodyIterator(resp) self.assertEqual(size, len(body))
def json_request(self, method, url, **kwargs): self.url = url return utils.FakeResponse({}), ParameterFakeAPI.image_list
def test_body_size(self): size = 1000000007 resp = utils.FakeResponse({'content-length': str(size)}, StringIO.StringIO('BB')) body = http.ResponseBodyIterator(resp) self.assertEqual(len(body), size)