def test_different_viewer_returns_public_apps(self, filter_mock):
owner = utils.get_user_mock()
viewer = utils.get_user_mock()
result = views.get_application_list(owner, viewer=viewer)
filter_mock.assert_called_once_with(
owner=owner, status=Application.PUBLISHED)
eq_(list(result), [])
def test_request_is_successful(self):
request = utils.get_request(
'get', '/org/', user=utils.get_user_mock())
response = views.organization_list(request)
eq_(response.status_code, 200)
eq_(response.template_name, 'organizations/object_list.html')
eq_(sorted(response.context_data.keys()), ['page'])
def test_organization_does_not_exist(self, mock_get):
mock_get.side_effect = Http404
request = utils.get_request(
'get', '/org/foo/edit/', user=utils.get_user_mock())
assert_raises(Http404, views.organization_edit, request, 'foo')
mock_get.assert_called_once_with(
Organization, slug__exact='foo', members=request.user)
def test_empty_post_request_fails(self, mock_get):
mock_profile = Mock(spec=Profile)()
mock_get.return_value = mock_profile
request = utils.get_request(
'post', '/contact/foo/', data={}, user=utils.get_user_mock())
response = views.contact_user(request, 'foo')
ok_(response.context_data['form'].errors)
def test_get_request_is_successful(self):
request = utils.get_request(
'get', '/resource/add/', user=utils.get_user_mock())
response = views.resource_add(request)
eq_(response.status_code, 200)
eq_(response.template_name, 'resources/object_add.html')
eq_(sorted(response.context_data.keys()), ['form'])
def test_owner_returns_all_available_objects(
self, owned_mock, membership_mock):
contact = utils.get_user_mock()
result = views.get_hub_list(contact, viewer=contact)
owned_mock.assert_called_once_with(contact, viewer=contact)
membership_mock.assert_called_once_with(contact, viewer=contact)
eq_(result, [])
def test_anon_user_returns_public_objects(self, filter_mock):
contact = utils.get_user_mock()
viewer = utils.get_anon_mock()
result = views.get_resource_list(contact, viewer=viewer)
filter_mock.assert_called_once_with(
contact=contact, status=Resource.PUBLISHED)
eq_(list(result), [])
def test_non_existing_app_raises_404(self, get_mock):
get_mock.side_effect = Http404
request = self.factory.get('/app/b/membership/')
request.user = utils.get_user_mock()
assert_raises(Http404, views.app_membership, request, 'b')
get_mock.assert_called_once_with(
Application.active, slug__exact='b')
def test_get_request_is_successful(self):
request = self.factory.get('/app/add/')
request.user = utils.get_user_mock()
response = views.app_add(request)
eq_(response.status_code, 200)
eq_(sorted(response.context_data.keys()), ['form'])
eq_(response.template_name, 'apps/object_add.html')
def test_challenge_does_not_exist(self, mock_get):
mock_get.side_effect = [Mock(spec=Application), Http404]
request = utils.get_request(
'get', '/challenges/foo/enter/abc/', user=utils.get_user_mock())
assert_raises(Http404, views.challenge_entry, request, 'foo', 'abc')
mock_get.assert_any_call(
Challenge, slug__exact='foo', status=Challenge.PUBLISHED)
def test_empty_post_request_fails(self, save_mock):
request = self.factory.post('/app/add/', {})
request.user = utils.get_user_mock()
response = views.app_add(request)
eq_(response.status_code, 200)
ok_(response.context_data['form'].errors)
eq_(save_mock.call_count, 0)
def test_awards_are_returned(self, mock_related):
mock_related.return_value.filter.return_value = []
user = utils.get_user_mock()
result = views.get_award_list(user)
eq_(result, [])
mock_related.assert_called_once_with('award')
mock_related.return_value.filter.assert_called_once_with(user=user)
def test_anon_user_returns_public_objects(self, owned_mock, membership_mock):
contact = utils.get_user_mock()
viewer = utils.get_anon_mock()
result = views.get_hub_list(contact, viewer=viewer)
owned_mock.assert_called_once_with(contact, viewer=viewer)
membership_mock.assert_called_once_with(contact, viewer=viewer)
eq_(result, [])
def test_owner_returns_all_available_objects(self, related_mock):
filter_mock = Mock()
filter_mock.filter.return_value = HubMembership.objects.none()
related_mock.return_value = filter_mock
user = utils.get_user_mock()
result = views.get_hub_membership_list(user, viewer=user)
related_mock.assert_called_once_with('hub')
filter_mock.filter.assert_called_once_with(user=user)
def test_get_request_is_successful(self, mock_filter):
request = utils.get_request(
'get', '/hub/apply/', user=utils.get_user_mock())
response = views.hub_application(request)
eq_(response.status_code, 200)
eq_(sorted(response.context_data.keys()), ['form', 'object_list'])
eq_(response.template_name, 'hubs/object_application.html')
mock_filter.assert_called_once()
def test_empty_submission_fails(self, *args):
request = utils.get_request(
'post', '/hub/apply/', data={}, user=utils.get_user_mock())
response = views.hub_application(request)
eq_(response.status_code, 200)
eq_(sorted(response.context_data.keys()), ['form', 'object_list'])
eq_(response.template_name, 'hubs/object_application.html')
ok_(response.context_data['form'].errors)
def test_get_request_is_successful(self, app_mock):
request = self.factory.get('/profile/delete/')
request.user = utils.get_user_mock()
response = views.user_profile_delete(request)
app_mock.assert_called_once_with(owner=request.user)
eq_(response.template_name, 'profile/user_profile_delete.html')
eq_(sorted(response.context_data.keys()),
sorted(['application_list', 'event_list', 'resource_list']))
def test_application_does_not_exist(self, mock_get):
mock_get.side_effect = Http404
request = utils.get_request(
'get', '/challenge/foo/enter/abc/', user=utils.get_user_mock())
assert_raises(Http404, views.challenge_entry, request, 'foo', 'abc')
mock_get.assert_called_once_with(
Application, slug__exact='abc', owner=request.user,
status=Application.PUBLISHED)
def test_owner_returns_all_available_objects(self, related_mock):
filter_mock = Mock()
filter_mock.filter.return_value = OrganizationMember.objects.none()
related_mock.return_value = filter_mock
user = utils.get_user_mock()
result = views.get_organization_list(user, viewer=user)
related_mock.assert_called_once_with('organization')
filter_mock.filter.assert_called_once_with(user=user)
def test_not_published_entry_raises_404(self, mock_related):
mock_related = mock_related.return_value
mock_entry = Mock(spec=Entry)()
mock_entry.is_visible_by.return_value = False
mock_related.get.return_value = mock_entry
request = utils.get_request(
'get', '/challenges/gigabit/app/', user=utils.get_user_mock())
assert_raises(Http404, views.entry_detail, request, 'gigabit', 'app')
mock_entry.is_visible_by.assert_called_once_with(request.user)
def test_get_request_is_valid(self, mock_get):
mock_profile = Mock(spec=Profile)()
mock_get.return_value = mock_profile
request = utils.get_request(
'get', '/contact/foo/', user=utils.get_user_mock())
response = views.contact_user(request, 'foo')
eq_(response.status_code, 200)
eq_(response.template_name, 'relay/contact_user.html')
eq_(sorted(response.context_data), ['form', 'object'])
def test_resource_requires_ownership(self, mock_get):
mock_instance = Mock(spec=Resource)
mock_instance.is_editable_by.return_value = False
mock_get.return_value = mock_instance
request = utils.get_request(
'get', '/resource/foo/edit/', user=utils.get_user_mock())
assert_raises(Http404, views.resource_edit, request, 'foo')
mock_get.assert_called_once_with(Resource, slug__exact='foo')
mock_instance.is_editable_by.assert_called_once_with(request.user)
def test_non_member_raises_404(self, mock_get):
app_mock = Mock(spec=Application)
app_mock.name = 'Gigabit'
app_mock.has_member.return_value = False
mock_get.return_value = app_mock
request = self.factory.get('/app/blue/export')
request.user = utils.get_user_mock()
assert_raises(Http404, views.app_export, request, 'blue')
mock_get.assert_called_once_with(Application.active, slug__exact='blue')
app_mock.has_member.assert_called_once_with(request.user)
def test_closed_challenge_redirects_to_detail_page(self, mock_get):
app_mock = Mock(spec=Application)
challenge_mock = Mock(spec=Challenge)
challenge_mock.is_open.return_value = False
mock_get.side_effect = [app_mock, challenge_mock]
request = utils.get_request(
'get', '/challenges/foo/enter/abc/', user=utils.get_user_mock())
response = views.challenge_entry(request, 'foo', 'abc')
eq_(response.status_code, 302)
eq_(response['Location'], '/challenges/foo/abc/')
def test_anon_user_returns_public_objects(self, related_mock):
filter_mock = Mock()
filter_mock.filter.return_value = OrganizationMember.objects.none()
related_mock.return_value = filter_mock
user = utils.get_user_mock()
viewer = utils.get_anon_mock()
result = views.get_organization_list(user, viewer=viewer)
related_mock.assert_called_once_with('organization')
filter_mock.filter.assert_called_once_with(
user=user, organization__status=Organization.PUBLISHED)
def test_anon_user_returns_public_objects(self, related_mock):
filter_mock = Mock()
filter_mock.filter.return_value = HubMembership.objects.none()
related_mock.return_value = filter_mock
user = utils.get_user_mock()
viewer = utils.get_anon_mock()
result = views.get_hub_membership_list(user, viewer=viewer)
related_mock.assert_called_once_with('hub')
filter_mock.filter.assert_called_once_with(
user=user, hub__status=Hub.PUBLISHED)
def test_removal_request_is_successful(self, logout_mock, app_mock):
app_mock.return_value = []
request = self.factory.post('/profile/delete/')
request.user = utils.get_user_mock()
request._messages = utils.TestMessagesBackend(request)
response = views.user_profile_delete(request)
app_mock.assert_called_once_with(owner=request.user)
request.user.delete.assert_called_once()
logout_mock.assert_called_once_with(request)
eq_(response.status_code, 302)
eq_(response['Location'], '/')
def test_entry_is_visible_when_challenge_finishes(self, mock_related):
mock_related = mock_related.return_value
mock_entry = Mock(spec=Entry)()
mock_entry.is_visible_by.return_value = True
mock_entry.challenge.has_finished.return_value = True
mock_related.get.return_value = mock_entry
request = utils.get_request(
'get', '/challenges/gigabit/app/', user=utils.get_user_mock())
response = views.entry_detail(request, 'gigabit', 'app')
eq_(response.status_code, 200)
eq_(response.template_name, 'challenges/entry_detail.html')
mock_entry.challenge.has_finished.assert_called_once()
def test_entry_is_not_visible_to_user_when_hidden(self, mock_related):
mock_related = mock_related.return_value
mock_entry = Mock(spec=Entry)()
mock_entry.is_visible_by.return_value = True
mock_entry.application.is_owned_by.return_value = False
mock_entry.challenge.has_finished.return_value = False
mock_entry.challenge.hide_entries = True
mock_related.get.return_value = mock_entry
request = utils.get_request(
'get', '/challenges/gigabit/app/', user=utils.get_user_mock())
assert_raises(Http404, views.entry_detail, request, 'gigabit', 'app')
mock_entry.challenge.has_finished.assert_called_once()
def test_simple_post_request_succeeds(self, save_m2m_mock, save_mock):
request = self.factory.post('/app/add/', _get_message_payload())
request._messages = utils.TestMessagesBackend(request)
request.user = utils.get_user_mock()
mock_instance = save_mock.return_value
mock_instance.get_absolute_url.return_value = '/app/slug/'
response = views.app_add(request)
eq_(response.status_code, 302)
eq_(response['Location'], '/app/slug/')
save_mock.assert_called_once_with(commit=False)
eq_(mock_instance.owner, request.user)
mock_instance.save.assert_called_once()
save_m2m_mock.assert_called_once()
