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)