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 TestContentSourceCollectionActionView(unittest.TestCase):
"""
Tests for content sources
"""
@mock.patch('pulp.server.webservices.views.decorators._verify_auth',
new=assert_auth_UPDATE())
def test_post_bad_request_content_source(self):
"""
Test content source invalid action
"""
request = mock.MagicMock()
request.body = None
content_source_view = ContentSourceCollectionActionView()
response = content_source_view.post(request, 'no-such-action')
self.assertTrue(isinstance(response, HttpResponseBadRequest))
self.assertEqual(response.status_code, 400)
@mock.patch('pulp.server.webservices.views.decorators._verify_auth',
new=assert_auth_UPDATE())
@mock.patch('pulp.server.webservices.views.content.tags')
@mock.patch('pulp.server.content.sources.container.ContentSource.load_all')
@mock.patch(
'pulp.server.webservices.views.content.content.refresh_content_sources'
)
def test_refresh_content_source(self, mock_refresh, mock_sources,
mock_tags):
"""
Test refresh content sources
"""
source = mock.MagicMock()
source.id = 'some-source'
source.dict.return_value = {'source_id': 'some-source'}
mock_sources.return_value = {'some-source': source}
mock_task_tags = [
mock_tags.action_tag.return_value,
mock_tags.resource_tag.return_value
]
request = mock.MagicMock()
request.body = None
content_source_view = ContentSourceCollectionActionView()
try:
content_source_view.post(request, 'refresh')
except OperationPostponed, 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 TestContentSourceResourceActionView(unittest.TestCase):
"""
Tests for content sources resource
"""
@mock.patch('pulp.server.webservices.views.decorators._verify_auth',
new=assert_auth_UPDATE())
@mock.patch('pulp.server.content.sources.container.ContentSource.load_all')
def test_post_invalid_action(self, mock_sources):
"""
Test specific content source invalid action
"""
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()
request.body = None
content_source_view = ContentSourceResourceActionView()
response = content_source_view.post(request, 'some-source',
'no-such-action')
self.assertTrue(isinstance(response, HttpResponseBadRequest))
self.assertEqual(response.status_code, 400)
@mock.patch('pulp.server.webservices.views.decorators._verify_auth',
new=assert_auth_UPDATE())
@mock.patch('pulp.server.content.sources.container.ContentSource.load_all')
def test_refresh_invalid_content_source(self, mock_sources):
"""
Test refresh invalid content source
"""
mock_sources.return_value = {}
request = mock.MagicMock()
request.body = None
content_source_view = ContentSourceResourceActionView()
try:
content_source_view.post(request, 'some-source', 'refresh')
except MissingResource, response:
pass
else:
class TestUploadSegmentResourceView(unittest.TestCase):
"""
Tests for views for uploads to a specific id.
"""
@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_upload_segment_resource(self, mock_factory, mock_resp):
"""
Test the UploadSegmentResourceView under normal conditions
"""
mock_upload_manager = mock.MagicMock()
mock_factory.content_upload_manager.return_value = mock_upload_manager
request = mock.MagicMock()
request.body = 'upload these bits'
upload_segment_resource = UploadSegmentResourceView()
response = upload_segment_resource.put(request, 'mock_id', 4)
mock_upload_manager.save_data.assert_called_once_with(
'mock_id', 4, 'upload these bits')
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.content.factory')
def test_put_upload_segment_resource_bad_offset(self, mock_factory):
"""
Test the UploadSegmentResourceView with an invalid offset value (not an int)
"""
mock_upload_manager = mock.MagicMock()
mock_factory.content_upload_manager.return_value = mock_upload_manager
request = mock.MagicMock()
upload_segment_resource = UploadSegmentResourceView()
self.assertRaises(InvalidValue, upload_segment_resource.put, request,
'mock_id', 'invalid_offset')
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)
request = mock.MagicMock()
request.body = None
content_source_view = ContentSourceResourceActionView()
try:
content_source_view.post(request, 'some-source', 'refresh')
except MissingResource, response:
pass
else:
raise AssertionError(
"MissingResource should be raised with missing resource id")
self.assertEqual(response.http_status_code, 404)
self.assertEqual(response.error_data['resources'],
{'source_id': 'some-source'})
@mock.patch('pulp.server.webservices.views.decorators._verify_auth',
new=assert_auth_UPDATE())
@mock.patch('pulp.server.webservices.views.content.tags')
@mock.patch('pulp.server.content.sources.container.ContentSource.load_all')
@mock.patch(
'pulp.server.webservices.views.content.content.refresh_content_source')
def test_refresh_specific_action(self, mock_refresh, mock_sources,
mock_tags):
"""
Test refresh 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}
mock_task_tags = [
"""
Test user deletion.
"""
mock_factory.user_manager.return_value.delete_user.return_value = None
mock_perm.return_value.find_one.return_value = 'some'
request = mock.MagicMock()
user = UserResourceView()
response = user.delete(request, 'test-user')
mock_factory.user_manager.return_value.delete_user.assert_called_once_with('test-user')
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())
@mock.patch('pulp.server.webservices.views.users.generate_json_response_with_pulp_encoder')
@mock.patch('pulp.server.webservices.views.users.factory')
def test_update_user(self, mock_factory, mock_resp):
"""
Test user update
"""
resp = {'login': '******', 'name': 'some-user', 'id': '12345'}
mock_factory.user_manager.return_value.update_user.return_value = resp
request = mock.MagicMock()
request.body = json.dumps({'delta': {'name': 'some-user'}})
user = UserResourceView()
response = user.put(request, 'test-user')
expected_cont = {'login': '******', 'name': 'some-user'}
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)
