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_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_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)