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 TestConsumerGroupBindingsView(unittest.TestCase):
"""
Represents consumer group binding.
"""
@mock.patch('pulp.server.webservices.views.decorators._verify_auth',
new=assert_auth_CREATE())
@mock.patch('pulp.server.webservices.views.consumer_groups.factory')
@mock.patch(
'pulp.server.webservices.views.consumer_groups.model.Repository.objects'
)
def test_verify_group_resources_repo(self, mock_repo_qs, mock_factory):
"""
Test verify group resources with repo missing.
"""
mock_factory.consumer_group_query_manager.return_value.get_group.return_value = 'test-group'
mock_repo_qs().first.return_value = None
mock_factory.repo_distributor_manager.return_value.get_distributor.return_value = 'yyy'
request = mock.MagicMock()
request.body = json.dumps({'repo_id': 'xxx', 'distributor_id': 'yyy'})
bind_view = ConsumerGroupBindingsView()
try:
response = bind_view.post(request, 'test-group')
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 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 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)
"""
request = mock.MagicMock()
request.body = json.dumps({'name': 'test-user'})
user = UsersView()
try:
response = user.post(request)
except MissingValue, response:
pass
else:
raise AssertionError(
"MissingValue should be raised with missing options")
self.assertEqual(response.http_status_code, 400)
self.assertEqual(response.error_data['property_names'], ['login'])
@mock.patch('pulp.server.webservices.views.decorators._verify_auth',
new=assert_auth_CREATE())
def test_create_invalid_param(self):
"""
Test user creation with invalid param.
"""
request = mock.MagicMock()
request.body = json.dumps({
'login': '******',
'password': '******',
'invalid_param': 'invalid'
})
user = UsersView()
try:
response = user.post(request)
except InvalidValue, response:
pass
class TestConsumerGroupContentActionView(unittest.TestCase):
"""
Test Consumer group content manipulation.
"""
@mock.patch('pulp.server.webservices.controllers.decorators._verify_auth',
new=assert_auth_CREATE())
def test_consumer_group_bad_request_content(self):
"""
Test consumer group invalid content action.
"""
request = mock.MagicMock()
consumer_group_content = ConsumerGroupContentActionView()
response = consumer_group_content.post(request, 'my-group',
'no_such_action')
self.assertTrue(isinstance(response, HttpResponseBadRequest))
self.assertEqual(response.status_code, 400)
@mock.patch('pulp.server.webservices.controllers.decorators._verify_auth',
new=assert_auth_CREATE())
@mock.patch('pulp.server.webservices.views.consumer_groups.factory')
def test_consumer_group_content_install(self, mock_factory):
"""
Test consumer group content installation.
"""
mock_factory.consumer_group_manager.return_value.install_content.return_value = 'ok'
request = mock.MagicMock()
request.body_as_json = {"units": [], "options": {}}
consumer_group_content = ConsumerGroupContentActionView()
self.assertRaises(OperationPostponed, consumer_group_content.post,
request, 'my-group', 'install')
mock_factory.consumer_group_manager(
).install_content.assert_called_once_with('my-group', [], {})
@mock.patch('pulp.server.webservices.controllers.decorators._verify_auth',
new=assert_auth_CREATE())
@mock.patch('pulp.server.webservices.views.consumer_groups.factory')
def test_consumer_group_content_update(self, mock_factory):
"""
Test consumer group content update.
"""
mock_factory.consumer_group_manager.return_value.update_content.return_value = 'ok'
request = mock.MagicMock()
request.body_as_json = {"units": [], "options": {}}
consumer_group_content = ConsumerGroupContentActionView()
self.assertRaises(OperationPostponed, consumer_group_content.post,
request, 'my-group', 'update')
mock_factory.consumer_group_manager(
).update_content.assert_called_once_with('my-group', [], {})
@mock.patch('pulp.server.webservices.controllers.decorators._verify_auth',
new=assert_auth_CREATE())
@mock.patch('pulp.server.webservices.views.consumer_groups.factory')
def test_consumer_group_content_uninstall(self, mock_factory):
"""
Test consumer group content uninstall.
"""
mock_factory.consumer_group_manager.return_value.uninstall_content.return_value = 'ok'
request = mock.MagicMock()
request.body_as_json = {"units": [], "options": {}}
consumer_group_content = ConsumerGroupContentActionView()
self.assertRaises(OperationPostponed, consumer_group_content.post,
request, 'my-group', 'uninstall')
mock_factory.consumer_group_manager(
).uninstall_content.assert_called_once_with('my-group', [], {})
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:
raise AssertionError("MissingValue should be raised with missing options")
self.assertEqual(response.http_status_code, 400)
self.assertEqual(response.error_data['property_names'], ['login'])
@mock.patch('pulp.server.webservices.controllers.decorators._verify_auth',
new=assert_auth_CREATE())
def test_create_invalid_param(self):
"""
Test user creation with invalid param.
"""
request = mock.MagicMock()
request.body = json.dumps({'login': '******', 'password': '******',
'invalid_param': 'invalid'})
user = UsersView()
try:
response = user.post(request)
except InvalidValue, response:
pass
else:
raise AssertionError("InvalidValue should be raised with invalid options")
self.assertEqual(response.http_status_code, 400)
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:
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:
