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:
