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)
