class TestContentUnitResourceView(unittest.TestCase): """ Tests for views of a single content unit. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.content.generate_json_response_with_pulp_encoder' ) @mock.patch('pulp.server.webservices.views.content.serial_content') @mock.patch('pulp.server.webservices.views.content.factory') def test_get_content_unit_resource_view(self, mock_factory, mock_serializers, mock_resp): """ Test ContentUnitResourceView when the requested unit is found. """ mock_cqm = mock.MagicMock() mock_cqm.get_content_unit_by_id.return_value = {} mock_factory.content_query_manager.return_value = mock_cqm request = mock.MagicMock() mock_serializers.content_unit_obj.return_value = {} mock_serializers.content_unit_child_link_objs.return_value = { 'child': 1 } content_unit_resource_view = ContentUnitResourceView() response = content_unit_resource_view.get(request, 'mock_type', 'mock_unit') expected_content = {'children': {'child': 1}} mock_resp.assert_called_once_with(expected_content) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.factory') def test_get_content_unit_resource_view_missing_content( self, mock_factory, mock_resp): """ Test ContentUnitResourceView when the requested unit is not found. """ mock_cqm = mock.MagicMock() mock_cqm.get_content_unit_by_id.side_effect = MissingResource() mock_factory.content_query_manager.return_value = mock_cqm request = mock.MagicMock() content_unit_resource_view = ContentUnitResourceView() response = content_unit_resource_view.get(request, 'mock_type', 'mock_unit') msg = _('No content unit resource: mock_unit') mock_resp.assert_called_once_with(msg, response_class=HttpResponseNotFound) self.assertTrue(response is mock_resp.return_value)
class TestPermissionsView(unittest.TestCase): """ Test permissions view. """ @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.permissions.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.permissions.factory') def test_get_all_permissions(self, mock_f, mock_resp): """ Test the permissions retrieval. """ perm = [{'resource': '/v2/some/', 'id': '1234', 'users': [{'username': '******', 'permissions': [0]}]}] mock_f.permission_query_manager.return_value.find_all.return_value = perm mock_f.permission_manager.return_value.operation_value_to_name.return_value = 'READ' request = mock.MagicMock() request.GET = {} permission = PermissionView() response = permission.get(request) expected_cont = [{'id': '1234', 'resource': '/v2/some/', 'users': {'test-user': ['READ']}}] mock_resp.assert_called_once_with(expected_cont) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.permissions.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.permissions.factory') def test_get_resource_permission(self, mock_f, mock_resp): """ Test specific resource permissions retrieval. """ perm = {'resource': '/v2/some/', 'id': '1234', 'users': [{'username': '******', 'permissions': [0]}]} mock_f.permission_query_manager.return_value.find_by_resource.return_value = perm mock_f.permission_manager.return_value.operation_value_to_name.return_value = 'READ' request = mock.MagicMock() request.body = json.dumps({'resource': '/v2/some/'}) permission = PermissionView() response = permission.get(request) expected_cont = [{'id': '1234', 'resource': '/v2/some/', 'users': {'test-user': ['READ']}}] mock_resp.assert_called_once_with(expected_cont) self.assertTrue(response is mock_resp.return_value)
class TestLoginView(unittest.TestCase): """ Tests for login view. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.root_actions.factory') def test_login(self, mock_factory): """ Test login that should return key and cert. """ mock_user = mock.MagicMock() mock_user.get_principal.return_value = 'mock_principle' mock_factory.principal_manager.return_value = mock_user mock_cert = mock.MagicMock() key_cert = {'key': 'key1', 'certificate': 'certificate1'} mock_cert.make_admin_user_cert.return_value = (key_cert['key'], key_cert['certificate']) mock_factory.cert_generation_manager.return_value = mock_cert request = mock.MagicMock() login_view = LoginView() response = login_view.post(request) self.assertTrue(isinstance(response, HttpResponse)) self.assertEqual(response.status_code, 200) self.assertEqual(response._headers.get('content-type'), ('Content-Type', 'application/json')) content = json.loads(response.content) self.assertEqual(content, key_cert)
class TestContentSourceCollectionView(unittest.TestCase): """ Tests for content sources """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.content.generate_json_response_with_pulp_encoder' ) @mock.patch('pulp.server.content.sources.container.ContentSource.load_all') def test_get_content_source(self, mock_sources, mock_resp): """ List all sources """ source = mock.MagicMock() source.id = 'my-id' source.dict.return_value = {'source_id': 'my-id'} mock_sources.return_value = {'mock': source} request = mock.MagicMock() content_source_view = ContentSourceCollectionView() response = content_source_view.get(request) mock_resp.assert_called_once_with([{ 'source_id': 'my-id', '_href': '/v2/content/sources/my-id/' }]) self.assertTrue(response is mock_resp.return_value)
class TestUsersView(unittest.TestCase): """ Test userss view. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.users.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.users.model.User') def test_get_users(self, mock_model, mock_resp): """ Test users retrieval. """ request = mock.MagicMock() view = UsersView() response = view.get(request) mock_model.serializer.assert_called_once_with(mock_model.objects.return_value, multiple=True) mock_resp.assert_called_once_with(mock_model.serializer.return_value.data) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_CREATE()) def test_create_missing_login(self): """ Test user creation with missing login. """ request = mock.MagicMock() request.body = json.dumps({'name': 'test-user'}) user = UsersView() try: response = user.post(request) except MissingValue, response: pass else:
class TestUserResourceView(unittest.TestCase): """ Test user resource view. """ @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.users.generate_json_response_with_pulp_encoder' ) @mock.patch('pulp.server.webservices.views.users.factory') def test_get_single_user(self, mock_f, mock_resp): """ Test single user retrieval. """ user = {'login': '******', 'name': 'test-user', 'id': '12345'} mock_f.user_query_manager.return_value.find_by_login.return_value = user request = mock.MagicMock() user = UserResourceView() response = user.get(request, 'test-user') expected_cont = { 'login': '******', 'name': 'test-user', '_href': '/v2/users/test-user/' } mock_resp.assert_called_once_with(expected_cont) mock_f.user_query_manager.return_value.find_by_login.assert_called_once_with( 'test-user') self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.users.factory') def test_get_invalid_user(self, mock_factory): """ Test nonexistent user retrieval. """ mock_factory.user_query_manager.return_value.find_by_login.return_value = None request = mock.MagicMock() user = UserResourceView() try: response = user.get(request, 'nonexistent_login') except MissingResource, response: pass else:
class TestRoleResourceView(unittest.TestCase): """ Test role resource view. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.roles.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.roles.factory') @mock.patch('pulp.server.webservices.views.roles.user_controller') def test_get_single_role(self, mock_ctrl, mock_f, mock_resp): """ Test single role retrieval. """ resp = {'id': 'test_role', 'users': [{'login': '******'}], 'permissions': [{'resource': '/', 'permission': [0]}]} user = mock.MagicMock() mock_f.role_query_manager.return_value.find_by_id.return_value = resp mock_ctrl.find_users_belonging_to_role.return_value = [user] mock_f.permission_manager.return_value.operation_value_to_name.return_value = 'READ' request = mock.MagicMock() role = RoleResourceView() response = role.get(request, 'test_role') expected_cont = {'id': 'test_role', 'permissions': {'/': ['READ']}, 'users': [user.login], '_href': '/v2/roles/test_role/'} mock_resp.assert_called_once_with(expected_cont) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.roles.factory') def test_get_nonexistent_role(self, mock_factory): """ Test invalid role retrieval. """ mock_factory.role_query_manager.return_value.find_by_id.return_value = None request = mock.MagicMock() role = RoleResourceView() try: response = role.get(request, 'nonexistent_id') except MissingResource, response: pass else:
class TestContentSourceResourceView(unittest.TestCase): """ Tests for content sources resource """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.content.generate_json_response_with_pulp_encoder' ) @mock.patch('pulp.server.content.sources.container.ContentSource.load_all') def test_get_content_source_resource(self, mock_sources, mock_resp): """ Get specific content source """ source = mock.MagicMock() source.id = 'some-source' source.dict.return_value = {'source_id': 'some-source'} mock_sources.return_value = {'some-source': source} request = mock.MagicMock() content_source_view = ContentSourceResourceView() response = content_source_view.get(request, 'some-source') mock_resp.assert_called_once_with({ 'source_id': 'some-source', '_href': '/v2/content/sources/some-source/' }) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.content.sources.container.ContentSource.load_all') def test_get_invalid_content_source_resource(self, mock_sources): """ Get invalid content source """ mock_sources.return_value = {} request = mock.MagicMock() content_source_view = ContentSourceResourceView() try: content_source_view.get(request, 'some-source') except MissingResource, response: pass else:
class TestUserResourceView(unittest.TestCase): """ Test user resource view. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.users.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.users.model.User') def test_get_single_user(self, mock_model, mock_resp): """ Test single user retrieval. """ request = mock.MagicMock() user = UserResourceView() response = user.get(request, 'test-user') mock_model.objects.get_or_404.assert_called_once_with(login='******') mock_resp.assert_called_once_with(mock_model.serializer.return_value.data) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_DELETE()) @mock.patch('pulp.server.webservices.views.users.reverse') @mock.patch('pulp.server.webservices.views.users.Permission.get_collection') @mock.patch('pulp.server.webservices.views.users.generate_json_response') @mock.patch('pulp.server.webservices.views.users.user_controller') def test_delete_single_user(self, mock_ctrl, mock_resp, mock_perm, mock_rev): """ Test user deletion. """ mock_perm().find_one.return_value = 'some' request = mock.MagicMock() user = UserResourceView() response = user.delete(request, 'test-user') mock_ctrl.delete_user.assert_called_once_with('test-user') mock_resp.assert_called_once_with() mock_perm().remove.assert_called_once_with({'resource': mock_rev.return_value}) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_UPDATE()) @mock.patch('pulp.server.webservices.views.users.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.users.model.User') @mock.patch('pulp.server.webservices.views.users.user_controller') def test_update_user(self, mock_ctrl, mock_model, mock_resp): """ Test user update """ request = mock.MagicMock() request.body = json.dumps({'delta': {'name': 'some-user'}}) user = UserResourceView() response = user.put(request, 'test-user') mock_ctrl.update_user.assert_called_once_with('test-user', {'name': 'some-user'}) mock_model.serializer.assert_called_once_with(mock_ctrl.update_user.return_value) mock_resp.assert_called_once_with(mock_model.serializer.return_value.data) self.assertTrue(response is mock_resp.return_value)
class TestRoleUsersView(unittest.TestCase): """ Test users membership within a role. """ @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.roles.generate_json_response_with_pulp_encoder' ) @mock.patch('pulp.server.webservices.views.roles.factory') def test_list_users_beloging_to_role(self, mock_fact, mock_resp): """ Test list Users belonging to a role. """ resp = {'login': '******', 'name': 'bar'} expected_cont = {'login': '******', 'name': 'bar'} mock_fact.user_query_manager.return_value.find_users_belonging_to_role.return_value = resp request = mock.MagicMock() role_users = RoleUsersView() response = role_users.get(request, 'test-role') mock_resp.assert_called_once_with(expected_cont) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_UPDATE()) @mock.patch('pulp.server.webservices.views.roles.generate_json_response') @mock.patch('pulp.server.webservices.views.roles.factory') def test_add_user_to_role(self, mock_factory, mock_resp): """ Test add user to a role. """ mock_factory.role_manager.return_value.add_user_to_role.return_value = None request = mock.MagicMock() request.body = json.dumps({'login': '******'}) role_users = RoleUsersView() response = role_users.post(request, 'test-role') mock_resp.assert_called_once_with(None) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_UPDATE()) def test_add_invalid_user_to_role(self): """ Test add invalid user to a role. """ request = mock.MagicMock() request.body = json.dumps({'login': None}) role_users = RoleUsersView() try: response = role_users.post(request, 'test-role') except InvalidValue, response: pass else:
class TestUploadsCollectionView(unittest.TestCase): """ Tests for views of all uploads. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.factory') def test_get_uploads_collection_view(self, mock_factory, mock_resp): """ View should return an response that contains a serialized dict with a list of upload_ids. """ mock_upload_manager = mock.MagicMock() mock_upload_manager.list_upload_ids.return_value = [ 'mock_upload_1', 'mock_upload_2' ] mock_factory.content_upload_manager.return_value = mock_upload_manager request = mock.MagicMock() content_types_view = UploadsCollectionView() response = content_types_view.get(request) expected_content = {'upload_ids': ['mock_upload_1', 'mock_upload_2']} mock_resp.assert_called_once_with(expected_content) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_CREATE()) @mock.patch( 'pulp.server.webservices.views.content.generate_redirect_response') @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.reverse') @mock.patch('pulp.server.webservices.views.content.factory') def test_post_uploads_collection_view(self, mock_factory, mock_reverse, mock_resp, mock_redirect): """ View post should return a response that contains data for a new upload. """ mock_upload_manager = mock.MagicMock() mock_upload_manager.initialize_upload.return_value = 'mock_id' mock_factory.content_upload_manager.return_value = mock_upload_manager request = mock.MagicMock() request.body = None mock_reverse.return_value = '/mock/path/' content_types_view = UploadsCollectionView() response = content_types_view.post(request) self.assertTrue(mock_upload_manager.initialize_upload.called) mock_resp.assert_called_once_with({ 'upload_id': 'mock_id', '_href': '/mock/path/' }) mock_redirect.assert_called_once_with(mock_resp.return_value, '/mock/path/') self.assertTrue(response is mock_redirect.return_value)
class TestOrphanCollectionView(unittest.TestCase): """ Tests for views for all orphaned content. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.content.reverse') @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.factory') def test_get_orphan_collection_view(self, mock_factory, mock_resp, mock_reverse): """ Orphan collection should create a response from a dict of orphan dicts. """ mock_orphans = { 'orphan1': 1, 'orphan2': 2, } mock_orphan_manager = mock.MagicMock() mock_orphan_manager.orphans_summary.return_value = mock_orphans mock_factory.content_orphan_manager.return_value = mock_orphan_manager request = mock.MagicMock() mock_reverse.return_value = '/mock/path/' orphan_collection = OrphanCollectionView() response = orphan_collection.get(request) expected_content = { 'orphan1': { 'count': 1, '_href': '/mock/path/', }, 'orphan2': { 'count': 2, '_href': '/mock/path/', }, } mock_resp.assert_called_once_with(expected_content) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_DELETE()) @mock.patch('pulp.server.webservices.views.content.content_orphan') def test_delete_orphan_collection_view(self, mock_orphan_manager): """ Delete orphan collection view should call the delete all orphans function. """ request = mock.MagicMock() orphan_collection = OrphanCollectionView() self.assertRaises(OperationPostponed, orphan_collection.delete, request) mock_orphan_manager.delete_all_orphans.apply_async.assert_called_once_with( tags=['pulp:content_unit:orphans'])
class TestRolesView(unittest.TestCase): """ Test roles view. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.roles.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.roles.factory') @mock.patch('pulp.server.webservices.views.roles.user_controller') def test_get_all_roles(self, mock_ctrl, mock_f, mock_resp): """ Test the roles retrieval. """ resp = [{'id': 'test_role', 'users': [{'login': '******'}], 'permissions': [{'resource': '/', 'permission': [0]}]}] user = mock.MagicMock() mock_f.role_query_manager.return_value.find_all.return_value = resp mock_ctrl.find_users_belonging_to_role.return_value = [user] mock_f.permission_manager.return_value.operation_value_to_name.return_value = 'READ' request = mock.MagicMock() roles = RolesView() response = roles.get(request) expected_cont = [{'id': 'test_role', 'permissions': {'/': ['READ']}, 'users': [user.login], '_href': '/v2/roles/test_role/'}] mock_resp.assert_called_once_with(expected_cont) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_CREATE()) @mock.patch('pulp.server.webservices.views.roles.generate_redirect_response') @mock.patch('pulp.server.webservices.views.roles.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.roles.factory') def test_create_role(self, mock_factory, mock_resp, mock_redirect): """ Test role creation. """ resp = {'id': 'foo', 'display_name': 'bar'} expected_cont = {'id': 'foo', 'display_name': 'bar', '_href': '/v2/roles/foo/'} request = mock.MagicMock() request.body = json.dumps({'role_id': 'foo', 'display_name': 'bar'}) mock_factory.role_manager.return_value.create_role.return_value = resp create_role = RolesView() response = create_role.post(request) mock_resp.assert_called_once_with(expected_cont) mock_redirect.assert_called_once_with(mock_resp.return_value, expected_cont['_href']) self.assertTrue(response is mock_redirect.return_value)
class TestContentUnitsCollectionView(unittest.TestCase): """ Tests for content units of a particular type. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.content.reverse') @mock.patch('pulp.server.webservices.views.content.serial_content') @mock.patch( 'pulp.server.webservices.views.content.generate_json_response_with_pulp_encoder' ) @mock.patch('pulp.server.webservices.views.content.factory') def test_get_content_units_collection_view(self, mock_factory, mock_resp, mock_serializers, mock_rev): """ View should return a response that contains a list of dicts, one for each content unit. """ def identity(arg): """ Allow a side effect to return an argument. """ return arg mock_cqm = mock.MagicMock() mock_cqm.find_by_criteria.return_value = [{ '_id': 'unit_1' }, { '_id': 'unit_2' }] mock_factory.content_query_manager.return_value = mock_cqm mock_serializers.content_unit_obj.side_effect = identity mock_serializers.content_unit_child_link_objs.return_value = 'child' request = mock.MagicMock() content_units_collection_view = ContentUnitsCollectionView() response = content_units_collection_view.get( request, {'content_type': 'mock_type'}) expected_content = [{ '_id': 'unit_1', '_href': mock_rev.return_value, 'children': 'child' }, { '_id': 'unit_2', '_href': mock_rev.return_value, 'children': 'child' }] mock_resp.assert_called_once_with(expected_content) self.assertTrue(response is mock_resp.return_value)
class TestOrphanResourceView(unittest.TestCase): """ Tests for views of a specific orphan. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.factory') def test_get_orphan_resource(self, mock_factory, mock_resp): """ Test get OrphanResourceView, which should return a dict describing an orphan. """ mock_orphan_manager = mock.MagicMock() mock_orphan_manager.get_orphan.return_value = {'_id': 'orphan'} mock_factory.content_orphan_manager.return_value = mock_orphan_manager request = mock.MagicMock() request.get_full_path.return_value = '/mock/path/' orphan_resource = OrphanResourceView() response = orphan_resource.get(request, 'mock_type', 'mock_id') expected_content = {'_id': 'orphan', '_href': '/mock/path/'} mock_resp.assert_called_once_with(expected_content) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_DELETE()) @mock.patch( 'pulp.server.webservices.views.content.factory.content_orphan_manager') @mock.patch('pulp.server.webservices.views.content.content_orphan') def test_delete_orphan_resource(self, mock_orphan_manager, mock_orphan): """ OrphanResourceView should call delete orphans by id and raise OperationPostponed. """ request = mock.MagicMock() orphan_resource = OrphanResourceView() self.assertRaises(OperationPostponed, orphan_resource.delete, request, 'mock_type', 'mock_id') mock_orphan_manager.delete_orphans_by_id.apply_async.assert_called_once_with( ([{ 'content_type_id': 'mock_type', 'unit_id': 'mock_id' }], ), tags=['pulp:content_unit:orphans']) mock_orphan.return_value.get_orphan.assert_called_once_with( 'mock_type', 'mock_id')
class TestEventView(unittest.TestCase): """ Test events view. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.events.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.events.factory') def test_get_events(self, mock_factory, mock_resp): """ Test events retrieval. """ events = [{'notifier_type_id': 'http', 'id': '12345'}] mock_factory.event_listener_manager.return_value.list.return_value = events request = mock.MagicMock() event_listeners = EventView() response = event_listeners.get(request) expected_cont = [{'id': '12345', '_href': '/v2/events/12345/', 'notifier_type_id': 'http'}] mock_resp.assert_called_once_with(expected_cont) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_CREATE()) @mock.patch('pulp.server.webservices.views.events.generate_redirect_response') @mock.patch('pulp.server.webservices.views.events.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.events.factory') def test_create_event(self, mock_factory, mock_resp, mock_redirect): """ Test event creation. """ resp = {'notifier_type_id': 'http', 'id': '12345', "event_types": ["foo", "bar"]} mock_factory.event_listener_manager.return_value.create.return_value = resp request = mock.MagicMock() request.body = json.dumps({'notifier_type_id': 'http', "event_types": ["foo", "bar"]}) event_listeners = EventView() response = event_listeners.post(request) expected_cont = {'id': '12345', '_href': '/v2/events/12345/', 'notifier_type_id': 'http', 'event_types': ['foo', 'bar']} mock_resp.assert_called_once_with(expected_cont) mock_redirect.assert_called_once_with(mock_resp.return_value, expected_cont['_href']) self.assertTrue(response is mock_redirect.return_value)
class TestOrphanTypeSubCollectionView(unittest.TestCase): """ Tests for views of orphans limited by type. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.content.reverse') @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.factory') def test_get_orphan_type_subcollection(self, mock_factory, mock_resp, mock_reverse): """ OrphanTypeSubCollection should return a response from a list of dicts, one for each orphan. """ mock_orphan_manager = mock.MagicMock() mock_orphan_manager.generate_orphans_by_type_with_unit_keys.return_value = [ { '_id': 'orphan1' }, { '_id': 'orphan2' } ] mock_factory.content_orphan_manager.return_value = mock_orphan_manager request = mock.MagicMock() mock_reverse.return_value = '/mock/path/' orphan_type_subcollection = OrphanTypeSubCollectionView() response = orphan_type_subcollection.get(request, 'mock_type') expected_content = [{ '_id': 'orphan1', '_href': '/mock/path/' }, { '_id': 'orphan2', '_href': '/mock/path/' }] mock_resp.assert_called_once_with(expected_content) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.factory') def test_get_orphan_type_subcollection_with_empty_list( self, mock_factory, mock_resp): """ View should return a response with an empty list when there are no orphans of the type. """ mock_orphan_manager = mock.MagicMock() mock_orphan_manager.generate_orphans_by_type_with_unit_keys.return_value = [] mock_factory.content_orphan_manager.return_value = mock_orphan_manager request = mock.MagicMock() orphan_type_subcollection = OrphanTypeSubCollectionView() response = orphan_type_subcollection.get(request, 'mock_type') expected_content = [] mock_resp.assert_called_once_with(expected_content) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_DELETE()) @mock.patch('pulp.server.controllers.units.get_unit_key_fields_for_type', spec_set=True) @mock.patch('pulp.server.webservices.views.content.content_orphan') def test_delete_orphan_type_subcollection(self, mock_orphan_manager, mock_get_unit_key_fields): """ Delete orphans should be called with the correct arguments and OperationPostponed is raised. """ request = mock.MagicMock() mock_get_unit_key_fields.return_value = ('id', ) orphan_type_subcollection = OrphanTypeSubCollectionView() self.assertRaises(OperationPostponed, orphan_type_subcollection.delete, request, 'mock_type') mock_orphan_manager.delete_orphans_by_type.apply_async.assert_called_once_with( ('mock_type', ), tags=['pulp:content_unit:orphans']) mock_get_unit_key_fields.assert_called_once_with('mock_type') @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_DELETE()) @mock.patch('pulp.server.controllers.units.get_unit_key_fields_for_type', spec_set=True) def test_delete_unknown_type(self, mock_get_unit_key_fields): mock_get_unit_key_fields.side_effect = ValueError request = mock.MagicMock() orphan_type_subcollection = OrphanTypeSubCollectionView() self.assertRaises(MissingResource, orphan_type_subcollection.delete, request, 'mock_type')
class TestContentUnitUserMetadataResourceView(unittest.TestCase): """ Tests for ContentUnitUserMetadataResourceView. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.content.serial_content') @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.factory') def test_get_content_unit_user_metadata_resource(self, mock_factory, mock_resp, mock_serial): """ View should return a response contains user metadata """ mock_unit = {constants.PULP_USER_METADATA_FIELDNAME: 'mock_metadata'} mock_cqm = mock_factory.content_query_manager() mock_cqm.get_content_unit_by_id.return_value = mock_unit mock_serial.content_unit_obj.return_value = 'mock_serial_metadata' request = mock.MagicMock() metadata_resource = ContentUnitUserMetadataResourceView() response = metadata_resource.get(request, 'mock_type', 'mock_unit') mock_serial.content_unit_obj.assert_called_once_with('mock_metadata') expected_content = 'mock_serial_metadata' mock_resp.assert_called_once_with(expected_content) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.factory') def test_get_content_unit_user_metadata_resource_no_unit( self, mock_factory, mock_resp): """ View should return a response not found and a helpful message when unit is not found. """ request = mock.MagicMock() mock_cqm = mock_factory.content_query_manager() mock_cqm.get_content_unit_by_id.side_effect = MissingResource() metadata_resource = ContentUnitUserMetadataResourceView() response = metadata_resource.get(request, 'mock_type', 'mock_unit') msg = _('No content unit resource: mock_unit') mock_resp.assert_called_once_with(msg, HttpResponseNotFound) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_UPDATE()) @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.factory') def test_put_content_unit_user_metadata_resource(self, mock_factory, mock_resp): """ Test update content unit user metdata resource. """ request = mock.MagicMock() request.body = json.dumps('mock_data') mock_cm = mock_factory.content_manager() metadata_resource = ContentUnitUserMetadataResourceView() response = metadata_resource.put(request, 'mock_type', 'mock_unit') mock_delta = {constants.PULP_USER_METADATA_FIELDNAME: 'mock_data'} mock_cm.update_content_unit.assert_called_once_with( 'mock_type', 'mock_unit', mock_delta) mock_resp.assert_called_with(None) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_UPDATE()) @mock.patch('pulp.server.webservices.views.content.generate_json_response') @mock.patch('pulp.server.webservices.views.content.factory') def test_put_content_unit_user_metadata_resource_no_unit( self, mock_factory, mock_resp): """ View should return a response not found and a helpful message when unit is not found. """ request = mock.MagicMock() request.body = json.dumps('') mock_cqm = mock_factory.content_query_manager() mock_cqm.get_content_unit_by_id.side_effect = MissingResource() metadata_resource = ContentUnitUserMetadataResourceView() response = metadata_resource.put(request, 'mock_type', 'mock_unit') msg = _('No content unit resource: mock_unit') mock_resp.assert_called_once_with(msg, HttpResponseNotFound) self.assertTrue(response is mock_resp.return_value)
class TestSearchView(unittest.TestCase): """ Test the SearchView class. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.search.criteria.Criteria.from_client_input') def test_get_no_query_params(self, from_client_input): """ Test the GET search handler without any parameters passed. """ class FakeSearchView(search.SearchView): model = mock.MagicMock() del model.SERIALIZER request = mock.MagicMock() request.GET = http.QueryDict('') view = FakeSearchView() FakeSearchView.model.objects.find_by_criteria.return_value = ['big money', 'bigger money'] with mock.patch.object(FakeSearchView, '_generate_response', side_effect=FakeSearchView._generate_response) as _generate_response: results = view.get(request) self.assertEqual(type(results), http.HttpResponse) self.assertEqual(results.content, '["big money", "bigger money"]') self.assertEqual(results.status_code, 200) _generate_response.assert_called_once_with({}, {}) from_client_input.assert_called_once_with({}) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.search.SearchView._generate_response') def test_get_with_options(self, mock_gen_response): """ Test the GET search handler without any search parameters passed, but with options. """ class FakeSearchView(search.SearchView): model = mock.MagicMock() _parse_args = mock.MagicMock(return_value=('query', 'options')) request = mock.MagicMock() request.GET = http.QueryDict('details=true') view = FakeSearchView() results = view.get(request) FakeSearchView._parse_args.assert_called_once_with({'details': 'true'}) mock_gen_response.assert_called_once_with('query', 'options') self.assertTrue(results is mock_gen_response.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.search.criteria.Criteria.from_client_input') def test_get_with_json_field(self, from_client_input): """ Test the GET search handler with a json field. This covers `filters` as well as `sort`. """ class FakeSearchView(search.SearchView): model = mock.MagicMock() del model.SERIALIZER request = mock.MagicMock() request.GET = http.QueryDict('filters={"name":"admin"}') view = FakeSearchView() FakeSearchView.model.objects.find_by_criteria.return_value = ['big money', 'bigger money'] with mock.patch.object(FakeSearchView, '_generate_response', side_effect=FakeSearchView._generate_response) as _generate_response: results = view.get(request) self.assertEqual(type(results), http.HttpResponse) self.assertEqual(results.content, '["big money", "bigger money"]') self.assertEqual(results.status_code, 200) _generate_response.assert_called_once_with({'filters': {"name": "admin"}}, {}) from_client_input.assert_called_once_with({'filters': {"name": "admin"}}) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.search.SearchView._parse_args') def test_get_with_invalid_filters(self, mock_parse): """ InvalidValue should be raised if param 'filters' is not json. """ mock_parse.return_value = ({'mock': 'query'}, 'tuple') search_view = search.SearchView() mock_request = mock.MagicMock() mock_request.GET = http.QueryDict('filters=invalid json') self.assertRaises(exceptions.InvalidValue, search_view.get, mock_request) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.search.criteria.Criteria.from_client_input') def test_get_with_fields(self, from_client_input): """ Test the GET search handler with fields in the request. """ class FakeSearchView(search.SearchView): model = mock.MagicMock() request = mock.MagicMock() request.GET = http.QueryDict('field=name&field=id&filters={"name":"admin"}') from_client_input.return_value = {} view = FakeSearchView() view.model.SERIALIZER.return_value.data = [{'serialized': 'content'}] with mock.patch.object(FakeSearchView, '_generate_response', side_effect=FakeSearchView._generate_response) as _generate_response: results = view.get(request) self.assertEqual(type(results), http.HttpResponse) self.assertEqual(results.content, '[{"serialized": "content"}]') self.assertEqual(results.status_code, 200) _generate_response.assert_called_once_with( {'fields': ['name', 'id'], 'filters': {'name': 'admin'}}, {}) from_client_input.assert_called_once_with( {'fields': ['name', 'id'], 'filters': {"name": "admin"}}) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) def test_post(self): """ Test the POST search under normal conditions. """ class FakeSearchView(search.SearchView): model = mock.MagicMock() del model.SERIALIZER request = mock.MagicMock() request.body = '{"criteria": {"filters": {"money": {"$gt": 1000000}}}}' view = FakeSearchView() FakeSearchView.model.objects.find_by_criteria.return_value = ['big money', 'bigger money'] with mock.patch.object(FakeSearchView, '_generate_response', side_effect=FakeSearchView._generate_response) as _generate_response: results = view.post(request) self.assertEqual(type(results), http.HttpResponse) self.assertEqual(results.content, '["big money", "bigger money"]') self.assertEqual(results.status_code, 200) _generate_response.assert_called_once_with({'filters': {'money': {'$gt': 1000000}}}, {}) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) def test_post_missing_criteria(self): """ Test that POST search when the user has not passed the required criteria. """ request = mock.MagicMock() # Simulate an empty POST body request.body = "{}" view = search.SearchView() try: view.post(request) self.fail('A MissingValue Exception should have been raised.') except exceptions.MissingValue, e: self.assertEqual(e.property_names, ['criteria'])
class TestUsersView(unittest.TestCase): """ Test userss view. """ @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.users.generate_json_response_with_pulp_encoder' ) @mock.patch('pulp.server.webservices.views.users.factory') def test_get_users(self, mock_factory, mock_resp): """ Test users retrieval. """ existing_users = [{ 'login': '******', 'name': 'test-user', 'id': '12345' }] mock_factory.user_query_manager.return_value.find_all.return_value = existing_users request = mock.MagicMock() view = UsersView() response = view.get(request) expected_cont = [{ '_href': '/v2/users/test-user/', 'login': '******', 'name': 'test-user' }] mock_resp.assert_called_once_with(expected_cont) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_CREATE()) @mock.patch( 'pulp.server.webservices.views.users.generate_redirect_response') @mock.patch( 'pulp.server.webservices.views.users.generate_json_response_with_pulp_encoder' ) @mock.patch('pulp.server.webservices.views.users.factory') def test_create_user(self, mock_factory, mock_resp, mock_redirect): """ Test user creation. """ resp = {'login': '******', 'name': 'test-user'} mock_factory.user_manager.return_value.create_user.return_value = resp request = mock.MagicMock() request.body = json.dumps({ 'login': '******', 'name': 'test-user', 'password': '******' }) user = UsersView() response = user.post(request) expected_cont = { '_href': '/v2/users/test-user/', 'login': '******', 'name': 'test-user' } mock_resp.assert_called_once_with(expected_cont) mock_redirect.assert_called_once_with(mock_resp.return_value, expected_cont['_href']) self.assertTrue(response is mock_redirect.return_value) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_CREATE()) def test_create_missing_login(self): """ Test user creation with missing login. """ request = mock.MagicMock() request.body = json.dumps({'name': 'test-user'}) user = UsersView() try: response = user.post(request) except MissingValue, response: pass else:
class TestSearchView(unittest.TestCase): """ Test the SearchView class. """ @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.search.criteria.Criteria.from_client_input' ) def test_get_with_fields(self, from_client_input): """ Test the GET search handler with fields in the request. """ class FakeSearchView(search.SearchView): model = mock.MagicMock() request = mock.MagicMock() # Simulate an empty POST body request.GET = {'field': ['name', 'id'], 'filters': '{"name":"admin"}'} view = FakeSearchView() FakeSearchView.model.objects.find_by_criteria.return_value = [ 'big money', 'bigger money' ] with mock.patch.object(FakeSearchView, '_generate_response', side_effect=FakeSearchView._generate_response ) as _generate_response: results = view.get(request) self.assertEqual(type(results), http.HttpResponse) self.assertEqual(results.content, '["big money", "bigger money"]') self.assertEqual(results.status_code, 200) # This is actually a bug, but the intention of this Django port was to behave exactly like # The webpy handlers did, bugs included. When #312 is fixed, the tests below should fail, # because the get() handler should have deserialized the filters instead of leaving them as # strings. Please modify these assertions to have the correct behavior. # https://pulp.plan.io/issues/312 _generate_response.assert_called_once_with({ 'fields': ['name', 'id'], 'filters': { "name": "admin" } }) from_client_input.assert_called_once_with({ 'fields': ['name', 'id'], 'filters': { "name": "admin" } }) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.search.criteria.Criteria.from_client_input' ) def test_get_without_fields(self, from_client_input): """ Test the GET search handler without any fields specified in the request. """ class FakeSearchView(search.SearchView): model = mock.MagicMock() request = mock.MagicMock() # Simulate an empty POST body request.GET = {'filters': '{"name":"admin"}'} view = FakeSearchView() FakeSearchView.model.objects.find_by_criteria.return_value = [ 'big money', 'bigger money' ] with mock.patch.object(FakeSearchView, '_generate_response', side_effect=FakeSearchView._generate_response ) as _generate_response: results = view.get(request) self.assertEqual(type(results), http.HttpResponse) self.assertEqual(results.content, '["big money", "bigger money"]') self.assertEqual(results.status_code, 200) # This is actually a bug, but the intention of this Django port was to behave exactly like # The webpy handlers did, bugs included. When #312 is fixed, the tests below should fail, # because the get() handler should have deserialized the filters instead of leaving them as # strings. Please modify these assertions to have the correct behavior. # https://pulp.plan.io/issues/312 _generate_response.assert_called_once_with( {'filters': { "name": "admin" }}) from_client_input.assert_called_once_with( {'filters': { "name": "admin" }}) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) def test_post(self): """ Test the POST search under normal conditions. """ class FakeSearchView(search.SearchView): model = mock.MagicMock() request = mock.MagicMock() # Simulate an empty POST body request.body = '{"criteria": {"filters": {"money": {"$gt": 1000000}}}}' view = FakeSearchView() FakeSearchView.model.objects.find_by_criteria.return_value = [ 'big money', 'bigger money' ] with mock.patch.object(FakeSearchView, '_generate_response', side_effect=FakeSearchView._generate_response ) as _generate_response: results = view.post(request) self.assertEqual(type(results), http.HttpResponse) self.assertEqual(results.content, '["big money", "bigger money"]') self.assertEqual(results.status_code, 200) _generate_response.assert_called_once_with( {'filters': { 'money': { '$gt': 1000000 } }}) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) def test_post_missing_criteria(self): """ Test that POST search when the user has not passed the required criteria. """ request = mock.MagicMock() # Simulate an empty POST body request.body = "{}" view = search.SearchView() try: view.post(request) self.fail('A MissingValue Exception should have been raised.') except exceptions.MissingValue, e: self.assertEqual(e.property_names, ['criteria'])
class TestconsumerGroupResourceView(unittest.TestCase): """ Test consumer groups resource view. """ @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_DELETE()) @mock.patch( 'pulp.server.webservices.views.consumer_groups.generate_json_response') @mock.patch('pulp.server.webservices.views.consumer_groups.factory') def test_delete_consumer_group_resource(self, mock_factory, mock_resp): """ Test consumer group delete resource. """ mock_group_manager = mock.MagicMock() mock_factory.consumer_group_manager.return_value = mock_group_manager mock_group_manager.delete_consumer_group.return_value = None request = mock.MagicMock() consumer_group_resource = ConsumerGroupResourceView() response = consumer_group_resource.delete(request, 'test-group') mock_group_manager.delete_consumer_group.assert_called_once_with( 'test-group') mock_resp.assert_called_once_with(None) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.consumer_groups.generate_json_response_with_pulp_encoder' ) @mock.patch( 'pulp.server.webservices.views.consumer_groups.ConsumerGroup.get_collection' ) def test_get_consumer_group_resource(self, mock_collection, mock_resp): """ Test single consumer group retrieval. """ consumer_mock = mock.MagicMock() consumer_mock.find_one.return_value = {'id': 'foo'} mock_collection.return_value = consumer_mock request = mock.MagicMock() consumer_group = ConsumerGroupResourceView() response = consumer_group.get(request, 'foo') expected_cont = {'id': 'foo', '_href': '/v2/consumer_groups/foo/'} mock_resp.assert_called_once_with(expected_cont) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.consumer_groups.ConsumerGroup.get_collection' ) def test_get_invalid_consumer_group_resource(self, mock_collection): """ Test nonexistent consumer group retrieval. """ mock_collection.return_value.find_one.return_value = None request = mock.MagicMock() consumer_group = ConsumerGroupResourceView() try: response = consumer_group.get(request, 'nonexistent_id') except MissingResource, response: pass else:
class TestEventResourceView(unittest.TestCase): """ Test event resource view. """ @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_READ()) @mock.patch('pulp.server.webservices.views.events.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.events.factory') def test_get_single_event(self, mock_factory, mock_resp): """ Test single event retrieval. """ event = {'notifier_type_id': 'http', 'id': '12345'} mock_factory.event_listener_manager.return_value.get.return_value = event request = mock.MagicMock() event_listeners = EventResourceView() response = event_listeners.get(request, '12345') expected_cont = {'id': '12345', '_href': '/v2/events/12345/', 'notifier_type_id': 'http'} mock_resp.assert_called_once_with(expected_cont) mock_factory.event_listener_manager.return_value.get.assert_called_once_with('12345') self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_DELETE()) @mock.patch('pulp.server.webservices.views.events.generate_json_response') @mock.patch('pulp.server.webservices.views.events.factory') def test_delete_single_event(self, mock_factory, mock_resp): """ Test event deletion. """ mock_factory.event_listener_manager.return_value.delete.return_value = None request = mock.MagicMock() event_listeners = EventResourceView() response = event_listeners.delete(request, '12345') mock_factory.event_listener_manager.return_value.delete.assert_called_once_with('12345') mock_resp.assert_called_once_with(None) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.views.decorators._verify_auth', new=assert_auth_UPDATE()) @mock.patch('pulp.server.webservices.views.events.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.events.factory') def test_update_event(self, mock_factory, mock_resp): """ Test event update """ resp = {'notifier_type_id': 'http', 'id': '12345', 'event_types': ['some']} mock_factory.event_listener_manager.return_value.update.return_value = resp request = mock.MagicMock() request.body = json.dumps({'event_types': ['some']}) event_listeners = EventResourceView() response = event_listeners.put(request, '12345') expected_cont = {'id': '12345', '_href': '/v2/events/12345/', 'notifier_type_id': 'http', 'event_types': ['some']} mock_resp.assert_called_once_with(expected_cont) self.assertTrue(response is mock_resp.return_value)
class TestconsumerGroupView(unittest.TestCase): """ Test consumer groups view. """ @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_READ()) @mock.patch( 'pulp.server.webservices.views.consumer_groups.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.consumer_groups.ConsumerGroup.get_collection') def test_get_all_consumer_groups(self, mock_collection, mock_resp): """ Test the consumer groups retrieval. """ consumer_mock = mock.MagicMock() resp = [{'id': 'foo', 'display_name': 'bar'}] consumer_mock.find.return_value = resp mock_collection.return_value = consumer_mock request = mock.MagicMock() consumer_group = ConsumerGroupView() response = consumer_group.get(request) expected_cont = [{'id': 'foo', 'display_name': 'bar', '_href': '/v2/consumer_groups/foo/'}] mock_resp.assert_called_once_with(expected_cont) self.assertTrue(response is mock_resp.return_value) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_CREATE()) @mock.patch('pulp.server.webservices.views.consumer_groups.generate_redirect_response') @mock.patch( 'pulp.server.webservices.views.consumer_groups.generate_json_response_with_pulp_encoder') @mock.patch('pulp.server.webservices.views.consumer_groups.factory') def test_create_consumer_group(self, mock_factory, mock_resp, mock_redirect): """ Test consumer group creation. """ resp = {'id': 'foo', 'display_name': 'bar'} expected_cont = {'id': 'foo', 'display_name': 'bar', '_href': '/v2/consumer_groups/foo/'} request = mock.MagicMock() request.body = json.dumps({'id': 'foo', 'display_name': 'bar'}) mock_factory.consumer_group_manager.return_value.create_consumer_group.return_value = resp consumer_group = ConsumerGroupView() response = consumer_group.post(request) mock_resp.assert_called_once_with(expected_cont) mock_redirect.assert_called_once_with(mock_resp.return_value, expected_cont['_href']) self.assertTrue(response is mock_redirect.return_value) @mock.patch('pulp.server.webservices.controllers.decorators._verify_auth', new=assert_auth_CREATE()) def test_create_consumer_group_invalid_param(self): """ Test consumer group creation with invalid parameters. """ request = mock.MagicMock() request.body = json.dumps({'id': 'foo', 'display_name': 'bar', 'invalid_param': 'some'}) consumer_group = ConsumerGroupView() try: response = consumer_group.post(request) except InvalidValue, response: pass else: