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(actual, expected)
def test_upload_wrong_content_type(self):
request = unit_test_utils.get_fake_request()
request.headers["Content-Type"] = "application/json"
request.body = "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 = "YYYYY"
self.assertRaises(webob.exc.HTTPUnsupportedMediaType, self.deserializer.upload, request)
def setUp(self):
super(TestTaskFactoryProxy, self).setUp()
factory = glance.domain.TaskFactory()
self.context = glance.context.RequestContext(tenant=TENANT1)
self.context_owner_is_none = glance.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_property_index(self):
request = unit_test_utils.get_fake_request()
output = self.property_controller.index(request, NAMESPACE3)
self.assertEqual(2, len(output.properties))
actual = set([property for property in output.properties])
expected = set([PROPERTY1, PROPERTY2])
self.assertEqual(expected, actual)
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_namespace_show_with_property_prefix(self):
request = unit_test_utils.get_fake_request()
rt = glance.api.v2.model.metadef_resource_type.\
ResourceTypeAssociation()
rt.name = RESOURCE_TYPE2
rt.prefix = 'pref'
rt = self.rt_controller.create(request, rt, NAMESPACE3)
object = glance.api.v2.model.metadef_object.MetadefObject()
object.name = OBJECT3
object.required = []
property = glance.api.v2.model.metadef_property_type.PropertyType()
property.name = PROPERTY2
property.type = 'string'
property.title = 'title'
object.properties = {'prop1': property}
object = self.object_controller.create(request, object, NAMESPACE3)
filters = {'resource_type': RESOURCE_TYPE2}
output = self.namespace_controller.show(request, NAMESPACE3, filters)
output = output.to_dict()
[self.assertTrue(property_name.startswith(rt.prefix)) for
property_name in output['properties'].keys()]
for object in output['objects']:
[self.assertTrue(property_name.startswith(rt.prefix)) for
property_name in object.properties.keys()]
def test_update_done_by_member_forbidden_by_policy(self):
rules = {"modify_member": False}
self.policy.set_rules(rules)
request = unit_test_utils.get_fake_request(tenant=TENANT4)
self.assertRaises(webob.exc.HTTPForbidden, self.controller.update,
request, image_id=UUID2, member_id=TENANT4,
status='accepted')
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_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_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(output['filters']['status'], status)
self.assertEqual(output['limit'], 1)
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(image.data, 'YYYY')
self.assertEqual(image.size, None)
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_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_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(actual, expected)
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_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.NotFound
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_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', status='active')
image = self.controller.download(request, unit_test_utils.UUID2)
self.assertEqual('abcd', image.image_id)
def test_upload_download_no_size(self):
request = unit_test_utils.get_fake_request()
self.controller.upload(request, unit_test_utils.UUID2, 'YYYY', None)
output = self.controller.download(request, unit_test_utils.UUID2)
self.assertEqual(set(['data', 'meta']), set(output.keys()))
self.assertEqual(4, output['meta']['size'])
self.assertEqual('YYYY', output['data'])
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_create(self):
request = unit_test_utils.get_fake_request()
request.body = jsonutils.dumps({'member': TENANT1})
image_id = UUID1
output = self.deserializer.create(request)
expected = {'member_id': TENANT1}
self.assertEqual(expected, output)
def test_update_invalid(self):
request = unit_test_utils.get_fake_request()
image_id = UUID1
member_id = TENANT1
request.body = jsonutils.dumps({'mem': TENANT1})
self.assertRaises(webob.exc.HTTPBadRequest, self.deserializer.update,
request)
def test_index_strip_params_from_filters(self):
name = 'My Little Image'
path = '/images?name=%s' % name
request = unit_test_utils.get_fake_request(path)
output = self.deserializer.index(request)
self.assertEqual(output['filters']['name'], name)
self.assertEqual(len(output['filters']), 1)
def test_update(self):
request = unit_test_utils.get_fake_request()
image = {'name': 'image-2'}
output = self.controller.update(request, UUID1, image)
self.assertEqual(UUID1, output['id'])
self.assertEqual('image-2', output['name'])
self.assertNotEqual(output['created_at'], output['updated_at'])
def test_update_public_image_unauthorized(self):
rules = {"modify_image": False}
self.policy.set_rules(rules)
request = unit_test_utils.get_fake_request()
image = {'name': 'image-1', 'is_public': True}
self.assertRaises(webob.exc.HTTPForbidden, self.controller.update,
request, UUID1, image)
def test_index_size_min_filter(self):
request = unit_test_utils.get_fake_request('/images?size_min=512')
output = self.controller.index(request, filters={'size_min': 512})
self.assertEqual(2, len(output['images']))
actual = set([image['id'] for image in output['images']])
expected = set([UUID2, UUID3])
self.assertEqual(actual, expected)
def test_index_default_limit(self):
self.config(limit_param_default=1, api_limit_max=3)
path = '/images'
request = unit_test_utils.get_fake_request(path)
output = self.controller.index(request)
actual = set([image['id'] for image in output['images']])
self.assertEquals(1, len(actual))
def test_index_with_filter_and_limit(self):
name = 'My Little Image'
path = '/images?name=%s&limit=1' % name
request = unit_test_utils.get_fake_request(path)
output = self.deserializer.index(request)
self.assertEqual(output['filters']['name'], name)
self.assertEqual(output['limit'], 1)
def test_update(self):
request = unit_test_utils.get_fake_request()
request.body = json.dumps({
'id': UUID3,
'name': 'image-1',
'visibility': 'public',
'tags': ['one', 'two'],
'container_format': 'ami',
'disk_format': 'ami',
'min_ram': 128,
'min_disk': 10,
'foo': 'bar',
'protected': True,
})
output = self.deserializer.update(request)
expected = {'image': {
'id': UUID3,
'name': 'image-1',
'is_public': True,
'tags': ['one', 'two'],
'container_format': 'ami',
'disk_format': 'ami',
'min_ram': 128,
'min_disk': 10,
'properties': {'foo': 'bar'},
'protected': True,
}}
self.assertEqual(expected, output)
def test_namespace_update_name_conflict(self):
request = unit_test_utils.get_fake_request()
namespace = self.namespace_controller.show(request, NAMESPACE1)
namespace.namespace = NAMESPACE2
self.assertRaises(webob.exc.HTTPConflict,
self.namespace_controller.update, request, namespace,
NAMESPACE1)
def test_upload_storage_internal_error(self):
request = unit_test_utils.get_fake_request()
self.image_repo.result = exception.ServerError()
self.assertRaises(exception.ServerError, self.controller.upload,
request, unit_test_utils.UUID1, 'ABC', 3)
def test_stage_without_glance_direct(self):
self.config(enabled_import_methods=['web-download'])
req = unit_test_utils.get_fake_request()
self.assertRaises(webob.exc.HTTPNotFound, self.deserializer.stage, req)
def test_get_not_allowed(self):
request = unit_test_utils.get_fake_request()
self.assertEqual(request.context.tenant, TENANT1)
self.assertRaises(webob.exc.HTTPNotFound, self.controller.get, request,
UUID4)
def test_index_non_integer_limit(self):
request = unit_test_utils.get_fake_request('/tasks?limit=blah')
self.assertRaises(webob.exc.HTTPBadRequest, self.deserializer.index,
request)
def test_index_strip_params_from_filters(self):
type = 'import'
path = '/tasks?type=%s' % type
request = unit_test_utils.get_fake_request(path)
output = self.deserializer.index(request)
self.assertEqual(output['filters']['type'], type)
def test_create_no_body(self):
request = unit_test_utils.get_fake_request()
self.assertRaises(webob.exc.HTTPBadRequest, self.deserializer.create,
request)
def test_delete(self):
request = unit_test_utils.get_fake_request()
self.assertRaises(webob.exc.HTTPMethodNotAllowed,
self.controller.delete, request, 'fake_id')
def test_index_unauthorized(self):
rules = {"get_tasks": False}
self.policy.set_rules(rules)
request = unit_test_utils.get_fake_request()
self.assertRaises(webob.exc.HTTPForbidden, self.controller.index,
request)
def test_get(self):
request = unit_test_utils.get_fake_request()
task = self.controller.get(request, task_id=UUID1)
self.assertEqual(UUID1, task.task_id)
self.assertEqual('import', task.type)
def test_get_non_existent(self):
request = unit_test_utils.get_fake_request()
task_id = str(uuid.uuid4())
self.assertRaises(webob.exc.HTTPNotFound, self.controller.get, request,
task_id)
def test_index_admin(self):
request = unit_test_utils.get_fake_request(is_admin=True)
output = self.controller.index(request)
self.assertEqual(4, len(output['tasks']))
def test_index_zero_tasks(self):
self.db.reset()
request = unit_test_utils.get_fake_request()
output = self.controller.index(request)
self.assertEqual([], output['tasks'])
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_index_sort_dir_bad_value(self):
request = unit_test_utils.get_fake_request('/tasks?sort_dir=invalid')
self.assertRaises(webob.exc.HTTPBadRequest, self.deserializer.index,
request)
def test_index_limit_not_specified(self):
request = unit_test_utils.get_fake_request('/tasks')
output = self.deserializer.index(request)
self.assertNotIn('limit', output)
def test_index_sort_key_id(self):
request = unit_test_utils.get_fake_request('/tasks?sort_key=id')
output = self.deserializer.index(request)
expected = {'sort_key': 'id', 'sort_dir': 'desc', 'filters': {}}
self.assertEqual(expected, output)
def test_index_invalid_status(self):
path = '/tasks?status=blah'
request = unit_test_utils.get_fake_request(path)
self.assertRaises(webob.exc.HTTPBadRequest, self.deserializer.index,
request)
def test_index_marker(self):
marker = str(uuid.uuid4())
path = '/tasks?marker=%s' % marker
request = unit_test_utils.get_fake_request(path)
output = self.deserializer.index(request)
self.assertEqual(marker, output.get('marker'))
def test_index_negative_limit(self):
path = '/tasks?limit=-1'
request = unit_test_utils.get_fake_request(path)
self.assertRaises(webob.exc.HTTPBadRequest, self.deserializer.index,
request)
def test_index_fraction(self):
request = unit_test_utils.get_fake_request('/tasks?limit=1.1')
self.assertRaises(webob.exc.HTTPBadRequest, self.deserializer.index,
request)
def test_empty_operation_type(self):
request = unit_test_utils.get_fake_request()
request.body = jsonutils.dumps({'actions': [_image_fixture('', '1')]})
self.assertRaises(webob.exc.HTTPBadRequest, self.deserializer.index,
request)
def test_access_delete_unauthorized(self):
rules = {"tasks_api_access": False}
self.policy.set_rules(rules)
request = unit_test_utils.get_fake_request()
self.assertRaises(webob.exc.HTTPForbidden, self.controller.delete,
request, 'fake_id')
def test_plugins_info_repo(self):
request = unit_test_utils.get_fake_request()
repo = glance.search.CatalogSearchRepo
repo.plugins_info = mock.Mock(return_value="{}")
self.search_controller.plugins_info(request)
repo.plugins_info.assert_called_once_with()
def test_empty_request(self):
request = unit_test_utils.get_fake_request()
request.body = jsonutils.dumps({})
self.assertRaises(webob.exc.HTTPBadRequest, self.deserializer.index,
request)
def test_upload_storage_quota_full(self):
request = unit_test_utils.get_fake_request()
self.image_repo.result = exception.StorageQuotaFull("message")
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
self.controller.upload, request,
unit_test_utils.UUID1, 'YYYYYYY', 7)
def test_plugins_info(self):
request = unit_test_utils.get_fake_request()
self.search_controller.plugins_info = mock.Mock(return_value="{}")
self.search_controller.plugins_info(request)
self.search_controller.plugins_info.assert_called_once_with(request)
def test_image_stage_raises_internal_error(self):
image_id = str(uuid.uuid4())
request = unit_test_utils.get_fake_request()
self.image_repo.result = exception.ServerError()
self.assertRaises(exception.ServerError, self.controller.stage,
request, image_id, 'YYYYYYY', 7)
def test_image_stage_raises_bad_store_uri(self, mock_store_configure):
mock_store_configure.side_effect = AttributeError()
image_id = str(uuid.uuid4())
request = unit_test_utils.get_fake_request()
self.assertRaises(exception.BadStoreUri, self.controller.stage,
request, image_id, 'YYYY', 4)
def test_download_forbidden(self):
request = unit_test_utils.get_fake_request()
self.image_repo.result = exception.Forbidden()
self.assertRaises(webob.exc.HTTPForbidden, self.controller.download,
request, str(uuid.uuid4()))
def test_image_stage_non_existent_image(self):
request = unit_test_utils.get_fake_request()
self.image_repo.result = exception.NotFound()
self.assertRaises(webob.exc.HTTPNotFound, self.controller.stage,
request, str(uuid.uuid4()), 'ABC', 3)
