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_organization_is_not_visible(self, mock_get):
mock_instance = Mock(spec=Organization)()
mock_get.return_value = mock_instance
mock_instance.is_visible_by.return_value = False
request = utils.get_request("get", "/organization/foo/", user=utils.get_anon_mock())
assert_raises(Http404, views.organization_detail, request, "foo")
mock_instance.is_visible_by.assert_called_once_with(request.user)
def test_entry_request_requires_authentication(self):
request = utils.get_request(
'get', '/challenges/foo/enter/abc/', user=utils.get_anon_mock())
response = views.challenge_entry(request, 'foo', 'abc')
eq_(response.status_code, 302)
eq_(response['Location'],
utils.get_login_url('/challenges/foo/enter/abc/'))
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_is_not_visible_when_is_draft(self):
user = get_user('us-ignite')
challenge = fixtures.get_challenge(user=user)
application = get_application(owner=user)
entry = fixtures.get_entry(
application, challenge=challenge, status=Entry.DRAFT)
eq_(entry.is_visible_by(utils.get_anon_mock()), False)
def test_entry_detail_requires_authentication(self):
request = utils.get_request(
'get', '/challenges/gigabit/app/', user=utils.get_anon_mock())
response = views.entry_detail(request, 'gigabit', 'app')
eq_(response.status_code, 302)
eq_(response['Location'],
utils.get_login_url('/challenges/gigabit/app/'))
def test_is_visible_for_published_challenges(self):
user = get_user('us-ignite')
challenge = fixtures.get_challenge(user=user)
application = get_application(owner=user)
entry = fixtures.get_entry(
application, challenge=challenge, status=Entry.SUBMITTED)
eq_(entry.is_visible_by(utils.get_anon_mock()), True)
def test_membership_requires_authentication(self):
request = utils.get_request(
'post', '/hub/community/membership/', user=utils.get_anon_mock())
response = views.hub_membership(request, 'community')
eq_(response.status_code, 302)
eq_(response['Location'],
utils.get_login_url('/hub/community/membership/'))
def test_invalid_published_post_returns_404(self, mock_get):
mock_get.side_effect = Http404
request = utils.get_request('get', '/blog/', user=utils.get_anon_mock())
assert_raises(Http404, views.post_detail, request, 2013, 12, 'gigabit')
mock_get.assert_called_once_with(
Post, slug='gigabit', publication_date__year=2013,
publication_date__month=12)
def setUp(self):
# key is a mk5 key, determined between the remote ip and
# path from the request
self.key = '8243f83255259f10db07a5c781f7c3ab'
self.factory = client.RequestFactory()
kwargs = {'HTTP_X_FORWARDED_FOR': '127.0.0.1'}
self.request = self.factory.get('/', **kwargs)
self.request.user = utils.get_anon_mock()
def test_get_request_is_successful(self, all_mock):
user = utils.get_anon_mock()
request = utils.get_request('get', '/hub/', user=user)
response = views.hub_list(request)
eq_(response.status_code, 200)
eq_(response.template_name, 'hubs/object_list.html')
eq_(sorted(response.context_data.keys()), ['page'])
all_mock.assert_called_once_with()
def challenge_detail_anon_request_is_valid(self, mock_filter):
request = utils.get_request(
'get', '/challenges/gigabit/', user=utils.get_anon_mock())
response = views.challenge_detail(request, 'gigabit')
eq_(response.status_code, 200)
eq_(response.template_name, 'challenges/object_detail.html')
eq_(sorted(response.context_data.keys()), ['entry_list', 'object'])
eq_(mock_filter.call_count, 0)
def test_event_list_request_is_successful(self, mock_filter):
mock_filter.return_value = []
request = utils.get_request("get", "/events/", user=utils.get_anon_mock())
response = views.event_list(request)
eq_(response.status_code, 200)
eq_(response.template_name, "events/object_list.html")
eq_(sorted(response.context_data.keys()), sorted(["page", "timeframe", "featured_list"]))
mock_filter.assert_called_once()
def test_resource_list_request_is_successful(self, mock_filter):
mock_filter.return_value = []
request = utils.get_request(
'get', '/resource/', user=utils.get_anon_mock())
response = views.resource_list(request)
eq_(response.status_code, 200)
eq_(response.template_name, 'resources/object_list.html')
eq_(sorted(response.context_data.keys()), ['page'])
def test_not_visible_event_raises_404(self, mock_get):
mock_instance = Mock(spec=Event)()
mock_instance.is_visible_by.return_value = False
mock_get.return_value = mock_instance
request = utils.get_request("get", "/event/abc/", user=utils.get_anon_mock())
assert_raises(Http404, views.event_detail, request, "abc")
mock_get.assert_called_once_with(Event, slug__exact="abc")
mock_instance.is_visible_by.assert_called_once()
def test_non_visible_resource_raises_404(self, mock_get):
instance_mock = Mock(spec=Resource)
instance_mock.is_visible_by.return_value = False
mock_get.return_value = instance_mock
request = utils.get_request(
'get', '/resource/foo/', user=utils.get_anon_mock())
assert_raises(Http404, views.resource_detail, request, 'foo')
mock_get.assert_called_once_with(Resource, slug__exact='foo')
instance_mock.is_visible_by.assert_called_once_with(request.user)
def test_request_is_successful(self, related_mock):
related_mock.return_value.filter.return_value = []
related_mock.return_value.all.return_value = []
request = utils.get_request('get', '/blog/', user=utils.get_anon_mock())
response = views.post_list(request)
eq_(response.status_code, 200)
eq_(response.template_name, 'blog/object_list.html')
eq_(sorted(response.context_data.keys()), ['featured_list', 'page'])
eq_(related_mock.return_value.filter.call_count, 2)
def test_valid_event_returns_calendar(self):
user = get_user("ignite-user")
event = fixtures.get_event(user=user, slug="abc", status=Event.PUBLISHED)
request = utils.get_request("get", "/event/abc/ics/", user=utils.get_anon_mock())
response = views.event_detail_ics(request, "abc")
eq_(response.status_code, 200)
ok_('attachment; filename="' in response["Content-Disposition"])
eq_(response["Content-Type"], "text/calendar")
ok_(response.content)
def test_organization_request_is_successful(self, mock_get):
mock_instance = Mock(spec=Organization)()
mock_get.return_value = mock_instance
mock_instance.is_visible_by.return_value = True
request = utils.get_request("get", "/org/foo/", user=utils.get_anon_mock())
response = views.organization_detail(request, "foo")
eq_(response.status_code, 200)
eq_(response.template_name, "organizations/object_detail.html")
eq_(sorted(response.context_data.keys()), ["is_member", "member_list", "object"])
def test_resource_request_is_successful(self, mock_get):
instance_mock = Mock(spec=Resource)
instance_mock.is_visible_by.return_value = True
mock_get.return_value = instance_mock
request = utils.get_request(
'get', '/resource/foo/', user=utils.get_anon_mock())
response = views.resource_detail(request, 'foo')
eq_(response.status_code, 200)
eq_(response.template_name, 'resources/object_detail.html')
eq_(response.context_data.keys(), ['object', 'is_owner'])
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_published_hub_request_is_successful(self):
fixtures.get_hub(name='community', status=models.Hub.PUBLISHED)
request = utils.get_request(
'get', '/hub/community/', user=utils.get_anon_mock())
response = views.hub_detail(request, 'community')
eq_(response.status_code, 200)
eq_(sorted(response.context_data.keys()),
sorted(['object', 'feature_list', 'member_list', 'is_member',
'is_contact', 'activity_list', 'event_list', 'award_list'])
)
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_not_visible_post_raises_404(self, mock_get):
mock_post = Mock(spec=Post)()
mock_post.is_visible_by.return_value = False
mock_get.return_value = mock_post
user = utils.get_anon_mock()
request = utils.get_request('get', '/blog/', user=user)
assert_raises(Http404, views.post_detail, request, 2013, 12, 'gigabit')
mock_get.assert_called_once_with(
Post, slug='gigabit', publication_date__year=2013,
publication_date__month=12)
mock_post.is_visible_by.assert_called_once_with(user)
def test_get_request_is_valid(self, mock_get):
mock_instance = Mock(spec=Event)()
mock_instance.audiences.all.return_value = []
mock_instance.is_visible_by.return_value = True
mock_instance.hubs.all.return_value = []
mock_get.return_value = mock_instance
request = utils.get_request("get", "/event/abc/", user=utils.get_anon_mock())
response = views.event_detail(request, "abc")
mock_get.assert_called_once_with(Event, slug__exact="abc")
mock_instance.is_visible_by.assert_called_once_with(request.user)
eq_(response.status_code, 200)
eq_(sorted(response.context_data.keys()), sorted(["hub_list", "is_owner", "object", "audience_list"]))
eq_(response.template_name, "events/object_detail.html")
def test_organization_request_is_successful(self, mock_get, mock_awards):
mock_instance = Mock(spec=Organization)()
mock_instance.interests.all.return_value = []
mock_get.return_value = mock_instance
mock_instance.is_visible_by.return_value = True
mock_awards.return_value = []
request = utils.get_request(
'get', '/org/foo/', user=utils.get_anon_mock())
response = views.organization_detail(request, 'foo')
eq_(response.status_code, 200)
eq_(response.template_name, 'organizations/object_detail.html')
eq_(sorted(response.context_data.keys()),
sorted(['interest_list', 'is_member', 'member_list', 'object',
'award_list']))
def test_published_post_request_is_successful(self, mock_get):
mock_post = Mock(spec=Post)()
mock_post.is_visible_by.return_value = True
mock_get.return_value = mock_post
request = utils.get_request('get', '/blog/', user=utils.get_anon_mock())
response = views.post_detail(request, 2013, 12, 'gigabit')
eq_(response.status_code, 200)
eq_(response.template_name, 'blog/object_detail.html')
eq_(sorted(response.context_data.keys()),
sorted(['object', 'featured_list']))
mock_get.assert_called_once_with(
Post, slug='gigabit', publication_date__year=2013,
publication_date__month=12)
mock_post.is_visible_by.assert_called_once_with(request.user)
def test_add_event_requires_auth(self):
request = utils.get_request("get", "/event/add/", user=utils.get_anon_mock())
response = views.event_add(request)
eq_(response.status_code, 302)
eq_(response["Location"], utils.get_login_url("/event/add/"))
def test_missing_event_raises_404(self, mock_get):
mock_get.side_effect = Http404
request = utils.get_request("get", "/event/abc/ics/", user=utils.get_anon_mock())
assert_raises(Http404, views.event_detail_ics, request, "abc")
mock_get.assert_called_once_with(Event.published, slug__exact="abc")
def test_published_hub_is_visible(self):
instance = fixtures.get_hub(status=Hub.PUBLISHED)
eq_(instance.is_visible_by(utils.get_anon_mock()), True)
