def test_delete_allowed_by_policies(self):
rules = {"get_member": True, "delete_member": True}
self.policy.set_rules(rules)
request = unit_test_utils.get_fake_request(tenant=TENANT1)
output = self.controller.delete(request,
image_id=UUID2,
member_id=TENANT4)
request = unit_test_utils.get_fake_request()
output = self.controller.index(request, UUID2)
self.assertEqual(0, len(output['members']))
def test_delete_by_member(self):
request = unit_test_utils.get_fake_request(tenant=TENANT4)
self.assertRaises(webob.exc.HTTPForbidden, self.controller.delete,
request, UUID2, TENANT4)
request = unit_test_utils.get_fake_request()
output = self.controller.index(request, UUID2)
self.assertEqual(1, len(output['members']))
actual = set(
[image_member.member_id for image_member in output['members']])
expected = set([TENANT4])
self.assertEqual(expected, actual)
def test_upload_wrong_content_type(self):
request = unit_test_utils.get_fake_request()
request.headers['Content-Type'] = 'application/json'
request.body = b'YYYYY'
self.assertRaises(webob.exc.HTTPUnsupportedMediaType,
self.deserializer.upload, request)
request = unit_test_utils.get_fake_request()
request.headers['Content-Type'] = 'application/octet-st'
request.body = b'YYYYY'
self.assertRaises(webob.exc.HTTPUnsupportedMediaType,
self.deserializer.upload, request)
def test_upload_wrong_content_type(self):
request = unit_test_utils.get_fake_request()
request.headers['Content-Type'] = 'application/json'
request.body = b'YYYYY'
self.assertRaises(webob.exc.HTTPUnsupportedMediaType,
self.deserializer.upload, request)
request = unit_test_utils.get_fake_request()
request.headers['Content-Type'] = 'application/octet-st'
request.body = b'YYYYY'
self.assertRaises(webob.exc.HTTPUnsupportedMediaType,
self.deserializer.upload, request)
def setUp(self):
super(TestTaskFactoryProxy, self).setUp()
factory = xmonitor.domain.TaskFactory()
self.context = xmonitor.context.RequestContext(tenant=TENANT1)
self.context_owner_is_none = xmonitor.context.RequestContext()
self.task_factory = authorization.TaskFactoryProxy(
factory, self.context)
self.task_type = 'import'
self.task_input = '{"loc": "fake"}'
self.owner = 'foo'
self.request1 = unittest_utils.get_fake_request(tenant=TENANT1)
self.request2 = unittest_utils.get_fake_request(tenant=TENANT2)
def setUp(self):
super(TestTaskFactoryProxy, self).setUp()
factory = xmonitor.domain.TaskFactory()
self.context = xmonitor.context.RequestContext(tenant=TENANT1)
self.context_owner_is_none = xmonitor.context.RequestContext()
self.task_factory = authorization.TaskFactoryProxy(
factory,
self.context
)
self.task_type = 'import'
self.task_input = '{"loc": "fake"}'
self.owner = 'foo'
self.request1 = unittest_utils.get_fake_request(tenant=TENANT1)
self.request2 = unittest_utils.get_fake_request(tenant=TENANT2)
def test_index_with_id_filter(self):
request = unit_test_utils.get_fake_request('/tasks?id=%s' % UUID1)
output = self.controller.index(request, filters={'id': UUID1})
self.assertEqual(1, len(output['tasks']))
actual = set([task.task_id for task in output['tasks']])
expected = set([UUID1])
self.assertEqual(expected, actual)
def test_create_task_unauthorized(self):
rules = {"add_task": False}
self.policy.set_rules(rules)
request = unit_test_utils.get_fake_request()
task = {'type': 'import', 'input': {"import_from": "fake"}}
self.assertRaises(webob.exc.HTTPForbidden, self.controller.create,
request, task)
def test_index_with_sort_dir(self):
path = '/tasks'
request = unit_test_utils.get_fake_request(path, is_admin=True)
output = self.controller.index(request, sort_dir='asc', limit=3)
actual = [task.task_id for task in output['tasks']]
self.assertEqual(3, len(actual))
self.assertEqual([UUID1, UUID2, UUID3], actual)
def test_create_task_unauthorized(self):
rules = {"add_task": False}
self.policy.set_rules(rules)
request = unit_test_utils.get_fake_request()
task = {'type': 'import', 'input': {"import_from": "fake"}}
self.assertRaises(webob.exc.HTTPForbidden, self.controller.create,
request, task)
def test_create_with_live_time(self, mock_validate_location_uri,
mock_get_image_data_iter):
request = unit_test_utils.get_fake_request()
task = {
"type": "import",
"input": {
"import_from": "http://download.cirros-cloud.net/0.3.4/"
"cirros-0.3.4-x86_64-disk.img",
"import_from_format": "qcow2",
"image_properties": {
"disk_format": "qcow2",
"container_format": "bare",
"name": "test-task"
}
}
}
new_task = self.controller.create(request, task=task)
executor_factory = self.gateway.get_task_executor_factory(
request.context)
task_executor = executor_factory.new_task_executor(request.context)
task_executor.begin_processing(new_task.task_id)
success_task = self.controller.get(request, new_task.task_id)
# ignore second and microsecond to avoid flaky runs
task_live_time = (
success_task.expires_at.replace(second=0, microsecond=0) -
success_task.updated_at.replace(second=0, microsecond=0))
task_live_time_hour = (task_live_time.days * 24 +
task_live_time.seconds / 3600)
self.assertEqual(CONF.task.task_time_to_live, task_live_time_hour)
def test_index_invalid_sort_key(self):
path = '/tasks'
request = unit_test_utils.get_fake_request(path)
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.index,
request,
sort_key='foo')
def test_index_with_sort_dir(self):
path = '/tasks'
request = unit_test_utils.get_fake_request(path, is_admin=True)
output = self.controller.index(request, sort_dir='asc', limit=3)
actual = [task.task_id for task in output['tasks']]
self.assertEqual(3, len(actual))
self.assertEqual([UUID1, UUID2, UUID3], actual)
def test_index_default_limit(self):
self.config(limit_param_default=1, api_limit_max=3)
path = '/tasks'
request = unit_test_utils.get_fake_request(path)
output = self.controller.index(request)
actual = set([task.task_id for task in output['tasks']])
self.assertEqual(1, len(actual))
def test_index_with_limit(self):
path = '/tasks'
limit = 2
request = unit_test_utils.get_fake_request(path, is_admin=True)
output = self.controller.index(request, limit=limit)
actual = set([task.task_id for task in output['tasks']])
self.assertEqual(limit, len(actual))
def test_index_with_limit(self):
path = '/tasks'
limit = 2
request = unit_test_utils.get_fake_request(path, is_admin=True)
output = self.controller.index(request, limit=limit)
actual = set([task.task_id for task in output['tasks']])
self.assertEqual(limit, len(actual))
def test_create(self):
request = unit_test_utils.get_fake_request()
request.body = jsonutils.dump_as_bytes({
'type': 'import',
'input': {
'import_from': 'swift://cloud.foo/myaccount/mycontainer/path',
'import_from_format': 'qcow2',
'image_properties': {
'name': 'fake1'
}
},
})
output = self.deserializer.create(request)
properties = {
'type': 'import',
'input': {
'import_from': 'swift://cloud.foo/myaccount/mycontainer/path',
'import_from_format': 'qcow2',
'image_properties': {
'name': 'fake1'
}
},
}
self.maxDiff = None
expected = {'task': properties}
self.assertEqual(expected, output)
def test_index_default_limit(self):
self.config(limit_param_default=1, api_limit_max=3)
path = '/tasks'
request = unit_test_utils.get_fake_request(path)
output = self.controller.index(request)
actual = set([task.task_id for task in output['tasks']])
self.assertEqual(1, len(actual))
def test_index_with_filter_and_limit(self):
status = 'success'
path = '/tasks?status=%s&limit=1' % status
request = unit_test_utils.get_fake_request(path)
output = self.deserializer.index(request)
self.assertEqual(status, output['filters']['status'])
self.assertEqual(1, output['limit'])
def test_create_with_live_time(self, mock_validate_location_uri,
mock_get_image_data_iter):
request = unit_test_utils.get_fake_request()
task = {
"type": "import",
"input": {
"import_from": "http://download.cirros-cloud.net/0.3.4/"
"cirros-0.3.4-x86_64-disk.img",
"import_from_format": "qcow2",
"image_properties": {
"disk_format": "qcow2",
"container_format": "bare",
"name": "test-task"
}
}
}
new_task = self.controller.create(request, task=task)
executor_factory = self.gateway.get_task_executor_factory(
request.context)
task_executor = executor_factory.new_task_executor(request.context)
task_executor.begin_processing(new_task.task_id)
success_task = self.controller.get(request, new_task.task_id)
# ignore second and microsecond to avoid flaky runs
task_live_time = (success_task.expires_at.replace(second=0,
microsecond=0) -
success_task.updated_at.replace(second=0,
microsecond=0))
task_live_time_hour = (task_live_time.days * 24 +
task_live_time.seconds / 3600)
self.assertEqual(CONF.task.task_time_to_live, task_live_time_hour)
def test_upload_data_to_store(self):
# 'user_storage_quota' is not set
def store_add(image_id, data, size, **kwargs):
# Check if 'data' is instance of 'CooperativeReader' when
# 'user_storage_quota' is disabled.
self.assertIsInstance(data, utils.CooperativeReader)
return location, 10, "checksum", {}
req = unit_test_utils.get_fake_request()
with self._get_store_and_notifier(
ext_update_data={'size': 10},
exc_class=store_add) as (location, checksum, image_meta,
image_data, store, notifier,
update_data):
ret = image_meta.update(update_data)
with patch.object(registry,
'update_image_metadata',
return_value=ret) as mock_update_image_metadata:
actual_meta, location_data = upload_utils.upload_data_to_store(
req, image_meta, image_data, store, notifier)
self.assertEqual(location, location_data['url'])
self.assertEqual(image_meta.update(update_data), actual_meta)
mock_update_image_metadata.assert_called_once_with(
req.context,
image_meta['id'],
update_data,
from_state='saving')
def test_index_with_filter_and_limit(self):
status = 'success'
path = '/tasks?status=%s&limit=1' % status
request = unit_test_utils.get_fake_request(path)
output = self.deserializer.index(request)
self.assertEqual(status, output['filters']['status'])
self.assertEqual(1, output['limit'])
def test_upload_data_to_store_not_found_after_upload(self):
req = unit_test_utils.get_fake_request()
with self._get_store_and_notifier(
ext_update_data={'size': 10}) as (location, checksum,
image_meta, image_data,
store, notifier,
update_data):
exc = exception.ImageNotFound
with patch.object(registry,
'update_image_metadata',
side_effect=exc) as mock_update_image_metadata:
with patch.object(upload_utils,
"initiate_deletion") as mock_initiate_del:
with patch.object(upload_utils,
"safe_kill") as mock_safe_kill:
self.assertRaises(webob.exc.HTTPPreconditionFailed,
upload_utils.upload_data_to_store,
req, image_meta, image_data, store,
notifier)
mock_update_image_metadata.assert_called_once_with(
req.context,
image_meta['id'],
update_data,
from_state='saving')
mock_initiate_del.assert_called_once_with(
req, {
'url': location,
'status': 'active',
'metadata': {}
}, image_meta['id'])
mock_safe_kill.assert_called_once_with(
req, image_meta['id'], 'saving')
def test_create_duplicate_tag_ignored(self):
request = unit_test_utils.get_fake_request()
self.controller.update(request, unit_test_utils.UUID1, 'dink')
self.controller.update(request, unit_test_utils.UUID1, 'dink')
context = request.context
tags = self.db.image_tag_get_all(context, unit_test_utils.UUID1)
self.assertEqual(1, len([tag for tag in tags if tag == 'dink']))
def test_upload_invalid(self):
request = unit_test_utils.get_fake_request()
image = FakeImage('abcd')
image.status = ValueError()
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPBadRequest, self.controller.upload,
request, unit_test_utils.UUID1, 'YYYY', 4)
def test_upload_no_size(self):
request = unit_test_utils.get_fake_request()
image = FakeImage('abcd')
self.image_repo.result = image
self.controller.upload(request, unit_test_utils.UUID2, 'YYYY', None)
self.assertEqual('YYYY', image.data)
self.assertIsNone(image.size)
def test_index_with_id_filter(self):
request = unit_test_utils.get_fake_request('/tasks?id=%s' % UUID1)
output = self.controller.index(request, filters={'id': UUID1})
self.assertEqual(1, len(output['tasks']))
actual = set([task.task_id for task in output['tasks']])
expected = set([UUID1])
self.assertEqual(expected, actual)
def test_download_no_location(self):
# NOTE(mclaren): NoContent will be raised by the ResponseSerializer
# That's tested below.
request = unit_test_utils.get_fake_request()
self.image_repo.result = FakeImage('abcd')
image = self.controller.download(request, unit_test_utils.UUID2)
self.assertEqual('abcd', image.image_id)
def test_upload_data_to_store(self):
# 'user_storage_quota' is not set
def store_add(image_id, data, size, **kwargs):
# Check if 'data' is instance of 'CooperativeReader' when
# 'user_storage_quota' is disabled.
self.assertIsInstance(data, utils.CooperativeReader)
return location, 10, "checksum", {}
req = unit_test_utils.get_fake_request()
with self._get_store_and_notifier(
ext_update_data={'size': 10},
exc_class=store_add) as (location, checksum, image_meta,
image_data, store, notifier,
update_data):
ret = image_meta.update(update_data)
with patch.object(registry, 'update_image_metadata',
return_value=ret) as mock_update_image_metadata:
actual_meta, location_data = upload_utils.upload_data_to_store(
req, image_meta, image_data, store, notifier)
self.assertEqual(location, location_data['url'])
self.assertEqual(image_meta.update(update_data), actual_meta)
mock_update_image_metadata.assert_called_once_with(
req.context, image_meta['id'], update_data,
from_state='saving')
def test_upload_data_to_store_not_found_after_upload(self):
req = unit_test_utils.get_fake_request()
with self._get_store_and_notifier(
ext_update_data={'size': 10}) as (location, checksum, image_meta,
image_data, store, notifier,
update_data):
exc = exception.ImageNotFound
with patch.object(registry, 'update_image_metadata',
side_effect=exc) as mock_update_image_metadata:
with patch.object(upload_utils,
"initiate_deletion") as mock_initiate_del:
with patch.object(upload_utils,
"safe_kill") as mock_safe_kill:
self.assertRaises(webob.exc.HTTPPreconditionFailed,
upload_utils.upload_data_to_store,
req, image_meta, image_data, store,
notifier)
mock_update_image_metadata.assert_called_once_with(
req.context, image_meta['id'], update_data,
from_state='saving')
mock_initiate_del.assert_called_once_with(
req, {'url': location, 'status': 'active',
'metadata': {}}, image_meta['id'])
mock_safe_kill.assert_called_once_with(
req, image_meta['id'], 'saving')
def test_upload_storage_forbidden(self):
request = unit_test_utils.get_fake_request(user=unit_test_utils.USER2)
image = FakeImage()
image.set_data = Raise(exception.Forbidden)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPForbidden, self.controller.upload,
request, unit_test_utils.UUID2, 'YY', 2)
def test_upload_no_size(self):
request = unit_test_utils.get_fake_request()
image = FakeImage('abcd')
self.image_repo.result = image
self.controller.upload(request, unit_test_utils.UUID2, 'YYYY', None)
self.assertEqual('YYYY', image.data)
self.assertIsNone(image.size)
def test_create_duplicate_tag_ignored(self):
request = unit_test_utils.get_fake_request()
self.controller.update(request, unit_test_utils.UUID1, 'dink')
self.controller.update(request, unit_test_utils.UUID1, 'dink')
context = request.context
tags = self.db.image_tag_get_all(context, unit_test_utils.UUID1)
self.assertEqual(1, len([tag for tag in tags if tag == 'dink']))
def test_upload_with_trusts(self, mock_refresher):
"""Test that uploading with registry correctly uses trusts"""
# initialize trust environment
self.config(data_api='xmonitor.db.registry.api')
refresher = mock.MagicMock()
mock_refresher.return_value = refresher
refresher.refresh_token.return_value = "fake_token"
# request an image upload
request = unit_test_utils.get_fake_request()
request.environ['keystone.token_auth'] = mock.MagicMock()
request.environ['keystone.token_info'] = {
'token': {
'roles': [{'name': 'FakeRole', 'id': 'FakeID'}]
}
}
image = FakeImage('abcd')
self.image_repo.result = image
mock_fake_save = mock.Mock()
mock_fake_save.side_effect = [None, exception.NotAuthenticated, None]
temp_save = FakeImageRepo.save
# mocking save to raise NotAuthenticated on the second call
FakeImageRepo.save = mock_fake_save
self.controller.upload(request, unit_test_utils.UUID2, 'YYYY', 4)
# check image data
self.assertEqual('YYYY', image.data)
self.assertEqual(4, image.size)
FakeImageRepo.save = temp_save
# check that token has been correctly acquired and deleted
mock_refresher.assert_called_once_with(
request.environ['keystone.token_auth'],
request.context.tenant, ['FakeRole'])
refresher.refresh_token.assert_called_once_with()
refresher.release_resources.assert_called_once_with()
self.assertEqual("fake_token", request.context.auth_token)
def test_show_by_member(self):
request = unit_test_utils.get_fake_request(tenant=TENANT4)
output = self.controller.show(request, UUID2, TENANT4)
expected = self.image_members[0]
self.assertEqual(expected['image_id'], output.image_id)
self.assertEqual(expected['member'], output.member_id)
self.assertEqual(expected['status'], output.status)
def test_upload_invalid(self):
request = unit_test_utils.get_fake_request()
image = FakeImage('abcd')
image.status = ValueError()
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPBadRequest, self.controller.upload,
request, unit_test_utils.UUID1, 'YYYY', 4)
def test_member(self):
req = unit_test_utils.get_fake_request()
output = self.controller.member(req)
self.assertEqual('member', output['name'])
expected = set(['status', 'created_at', 'updated_at', 'image_id',
'member_id', 'schema'])
self.assertEqual(expected, set(output['properties'].keys()))
def test_upload_storage_forbidden(self):
request = unit_test_utils.get_fake_request(user=unit_test_utils.USER2)
image = FakeImage()
image.set_data = Raise(exception.Forbidden)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPForbidden, self.controller.upload,
request, unit_test_utils.UUID2, 'YY', 2)
def test_download_no_location(self):
# NOTE(mclaren): NoContent will be raised by the ResponseSerializer
# That's tested below.
request = unit_test_utils.get_fake_request()
self.image_repo.result = FakeImage('abcd')
image = self.controller.download(request, unit_test_utils.UUID2)
self.assertEqual('abcd', image.image_id)
def test_index(self):
self.config(limit_param_default=1, api_limit_max=3)
request = unit_test_utils.get_fake_request()
output = self.controller.index(request)
self.assertEqual(1, len(output['tasks']))
actual = set([task.task_id for task in output['tasks']])
expected = set([UUID1])
self.assertEqual(expected, actual)
def test_index_with_filters_return_many(self):
path = '/tasks?status=pending'
request = unit_test_utils.get_fake_request(path, is_admin=True)
output = self.controller.index(request, filters={'status': 'pending'})
self.assertEqual(4, len(output['tasks']))
actual = set([task.task_id for task in output['tasks']])
expected = set([UUID1, UUID2, UUID3, UUID4])
self.assertEqual(sorted(expected), sorted(actual))
def test_update_invalid_status(self):
request = unit_test_utils.get_fake_request(tenant=TENANT4)
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.update,
request,
UUID2,
TENANT4,
status='accept')
def test_update_non_existent_image(self):
request = unit_test_utils.get_fake_request(tenant=TENANT1)
self.assertRaises(webob.exc.HTTPNotFound,
self.controller.update,
request,
'123',
TENANT4,
status='accepted')
def test_update_done_by_owner(self):
request = unit_test_utils.get_fake_request(tenant=TENANT1)
self.assertRaises(webob.exc.HTTPForbidden,
self.controller.update,
request,
UUID2,
TENANT4,
status='accepted')
def test_upload_signature_verification_fails(self):
request = unit_test_utils.get_fake_request()
image = FakeImage()
image.set_data = Raise(exception.SignatureVerificationError)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPBadRequest, self.controller.upload,
request, unit_test_utils.UUID1, 'YYYY', 4)
self.assertEqual('killed', self.image_repo.saved_image.status)
def test_index_with_marker(self):
self.config(limit_param_default=1, api_limit_max=3)
path = '/tasks'
request = unit_test_utils.get_fake_request(path, is_admin=True)
output = self.controller.index(request, marker=UUID3)
actual = set([task.task_id for task in output['tasks']])
self.assertEqual(1, len(actual))
self.assertIn(UUID2, actual)
def test_index_greater_than_limit_max(self):
self.config(limit_param_default=1, api_limit_max=3)
path = '/tasks'
request = unit_test_utils.get_fake_request(path, is_admin=True)
output = self.controller.index(request, limit=4)
actual = set([task.task_id for task in output['tasks']])
self.assertEqual(3, len(actual))
self.assertNotIn(output['next_marker'], output)
def test_index_zero_limit(self):
request = unit_test_utils.get_fake_request('/tasks?limit=0')
expected = {'limit': 0,
'sort_key': 'created_at',
'sort_dir': 'desc',
'filters': {}}
output = self.deserializer.index(request)
self.assertEqual(expected, output)
def test_image_size_limit_exceeded(self):
request = unit_test_utils.get_fake_request()
image = FakeImage()
image.set_data = Raise(exception.ImageSizeLimitExceeded)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
self.controller.upload,
request, unit_test_utils.UUID1, 'YYYYYYY', 7)
def test_upload_storage_store_disabled(self):
"""Test that uploading an image file raises StoreDisabled exception"""
request = unit_test_utils.get_fake_request(user=unit_test_utils.USER3)
image = FakeImage()
image.set_data = Raise(glance_store.StoreAddDisabled)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPGone, self.controller.upload, request,
unit_test_utils.UUID2, 'YY', 2)
def test_upload_storage_write_denied(self):
request = unit_test_utils.get_fake_request(user=unit_test_utils.USER3)
image = FakeImage()
image.set_data = Raise(glance_store.StorageWriteDenied)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPServiceUnavailable,
self.controller.upload,
request, unit_test_utils.UUID2, 'YY', 2)
def test_upload_storage_full(self):
request = unit_test_utils.get_fake_request()
image = FakeImage()
image.set_data = Raise(glance_store.StorageFull)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
self.controller.upload, request,
unit_test_utils.UUID2, 'YYYYYYY', 7)
def test_download(self):
request = unit_test_utils.get_fake_request()
image = FakeImage('abcd',
locations=[{'url': 'http://example.com/image',
'metadata': {}, 'status': 'active'}])
self.image_repo.result = image
image = self.controller.download(request, unit_test_utils.UUID1)
self.assertEqual('abcd', image.image_id)
def test_image_size_limit_exceeded(self):
request = unit_test_utils.get_fake_request()
image = FakeImage()
image.set_data = Raise(exception.ImageSizeLimitExceeded)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
self.controller.upload, request,
unit_test_utils.UUID1, 'YYYYYYY', 7)
def test_upload_signature_verification_fails(self):
request = unit_test_utils.get_fake_request()
image = FakeImage()
image.set_data = Raise(exception.SignatureVerificationError)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPBadRequest, self.controller.upload,
request, unit_test_utils.UUID1, 'YYYY', 4)
self.assertEqual('killed', self.image_repo.saved_image.status)
def test_upload_storage_write_denied(self):
request = unit_test_utils.get_fake_request(user=unit_test_utils.USER3)
image = FakeImage()
image.set_data = Raise(glance_store.StorageWriteDenied)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPServiceUnavailable,
self.controller.upload, request,
unit_test_utils.UUID2, 'YY', 2)
def test_upload_storage_full(self):
request = unit_test_utils.get_fake_request()
image = FakeImage()
image.set_data = Raise(glance_store.StorageFull)
self.image_repo.result = image
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
self.controller.upload,
request, unit_test_utils.UUID2, 'YYYYYYY', 7)
def test_index_sort_dir_asc(self):
request = unit_test_utils.get_fake_request('/tasks?sort_dir=asc')
output = self.deserializer.index(request)
expected = {
'sort_key': 'created_at',
'sort_dir': 'asc',
'filters': {}}
self.assertEqual(expected, output)
def test_safe_kill(self):
req = unit_test_utils.get_fake_request()
id = unit_test_utils.UUID1
with patch.object(registry, "update_image_metadata") as mock_registry:
upload_utils.safe_kill(req, id, 'saving')
mock_registry.assert_called_once_with(req.context, id,
{'status': 'killed'},
from_state='saving')
