def test_composer_detail_multi(self):
"""Composer shows its own page if multiple foias"""
foia = FOIARequestFactory(composer__status='filed')
FOIARequestFactory(composer=foia.composer)
composer = foia.composer
request = self.request_factory.get(
reverse('foia-composer-detail',
kwargs={
'slug': composer.slug,
'idx': composer.pk
}))
request.user = UserFactory()
request = mock_middleware(request)
response = ComposerDetail.as_view()(
request,
slug=composer.slug,
idx=composer.pk,
)
eq_(response.status_code, 200)
eq_(response.template_name, ['foia/foiacomposer_detail.html'])
def test_post_delete_update_composer(self):
"""Test deleting a composer"""
composer = FOIAComposerFactory(
status='started',
user__profile__num_requests=4,
)
data = {
'action': 'delete',
}
request = self.request_factory.post(
reverse('foia-draft', kwargs={
'idx': composer.pk
}),
data,
)
request.user = composer.user
request = mock_middleware(request)
response = UpdateComposer.as_view()(request, idx=composer.pk)
eq_(response.status_code, 302)
assert_false(FOIAComposer.objects.filter(pk=composer.pk).exists())
def test_expected_case(self, mock_requests):
"""
Giving the miniregister method a full name, email, and password should
create a user, create a profile, and log them in.
The method should return the authenticated user.
"""
mock_squarelet(mock_requests)
request = RequestFactory()
mixin = MiniregMixin()
form = Mock()
mixin.request = mock_middleware(request.get(reverse('foia-create')))
user = mixin.miniregister(form, self.full_name, self.email)
ok_(isinstance(user, User), 'A user should be created and returned.')
ok_(user.profile, 'A profile should be created for the user.')
ok_(user.is_authenticated(), 'The user should be logged in.')
eq_(user.profile.full_name, 'Lou Reed')
eq_(user.username, 'LouReed',
'The username should remove the spaces from the full name.')
def test_owner(self):
"""Crowdsource owner can fill out a private assignment"""
project = ProjectFactory()
crowdsource = CrowdsourceFactory(
status='open',
project_only=True,
project=project,
)
url = reverse(
'crowdsource-assignment',
kwargs={
'slug': crowdsource.slug,
'idx': crowdsource.pk
}
)
request = self.request_factory.get(url)
request = mock_middleware(request)
request.user = crowdsource.user
response = self.view(request, slug=crowdsource.slug, idx=crowdsource.pk)
eq_(response.status_code, 200)
def test_composer_detail_multi_submitted(self):
"""Composer shows its own page if multiple foias"""
foia = FOIARequestFactory(composer__status="submitted",
composer__datetime_submitted=timezone.now())
FOIARequestFactory(composer=foia.composer)
composer = foia.composer
request = self.request_factory.get(
reverse(
"foia-composer-detail",
kwargs={
"slug": composer.slug,
"idx": composer.pk
},
))
request.user = UserFactory()
request = mock_middleware(request)
response = ComposerDetail.as_view()(request,
slug=composer.slug,
idx=composer.pk)
eq_(response.status_code, 200)
eq_(response.template_name, ["foia/foiacomposer_detail.html"])
def test_composer_detail_private(self):
"""Composer is private if no viewable foias"""
foia = FOIARequestFactory(
embargo=True,
date_embargo=date.today() + timedelta(1),
composer__status='filed',
)
composer = foia.composer
request = self.request_factory.get(
reverse('foia-composer-detail',
kwargs={
'slug': composer.slug,
'idx': composer.pk
}))
request.user = UserFactory()
request = mock_middleware(request)
ComposerDetail.as_view()(
request,
slug=composer.slug,
idx=composer.pk,
)
def test_composer_detail_draft(self):
"""Composer detail view redirects to update page if draft"""
composer = FOIAComposerFactory(status='started')
request = self.request_factory.get(
reverse(
'foia-composer-detail',
kwargs={
'slug': composer.slug,
'idx': composer.pk
}
)
)
request.user = composer.user
request = mock_middleware(request)
response = ComposerDetail.as_view()(
request,
slug=composer.slug,
idx=composer.pk,
)
eq_(response.status_code, 302)
eq_(response.url, reverse('foia-draft', kwargs={'idx': composer.pk}))
def test_expected_case(self, mock_welcome):
"""
Giving the miniregister method a full name, email, and password should
create a user, create a profile, send them a welcome email, and log them in.
The method should return the authenticated user.
"""
request = RequestFactory()
mixin = MiniregMixin()
mixin.request = mock_middleware(request.get(reverse('foia-create')))
user = mixin.miniregister(self.full_name, self.email)
ok_(isinstance(user, User), 'A user should be created and returned.')
ok_(user.profile, 'A profile should be created for the user.')
ok_(user.is_authenticated(), 'The user should be logged in.')
mock_welcome.assert_called_once(
) # The user should get a welcome email
eq_(user.first_name, 'Lou',
'The first name should be extracted from the full name.')
eq_(user.last_name, 'Reed',
'The last name should be extracted from the full name.')
eq_(user.username, 'LouReed',
'The username should remove the spaces from the full name.')
def test_composer_detail_single_submitted(self):
"""Composer redirects to foia page if only a single request even
if it hasn't been filed yet"""
foia = FOIARequestFactory(composer__status="submitted",
composer__datetime_submitted=timezone.now())
composer = foia.composer
request = self.request_factory.get(
reverse(
"foia-composer-detail",
kwargs={
"slug": composer.slug,
"idx": composer.pk
},
))
request.user = UserFactory()
request = mock_middleware(request)
response = ComposerDetail.as_view()(request,
slug=composer.slug,
idx=composer.pk)
eq_(response.status_code, 302)
eq_(response.url, foia.get_absolute_url())
def test_grant_view_access(self):
"""Editors should be able to add viewers."""
user1 = UserFactory()
user2 = UserFactory()
view_data = {
'action': 'grant_access',
'users': [user1.pk, user2.pk],
'access': 'view'
}
view_request = self.factory.post(self.foia.get_absolute_url(),
view_data)
view_request = mock_middleware(view_request)
view_request.user = self.editor
view_response = Detail.as_view()(
view_request,
jurisdiction=self.foia.jurisdiction.slug,
jidx=self.foia.jurisdiction.id,
slug=self.foia.slug,
idx=self.foia.id)
eq_(view_response.status_code, 302)
assert_true(
self.foia.has_viewer(user1) and self.foia.has_viewer(user2))
def test_composer_detail_single(self):
"""Composer redirects to foia page if only a single request"""
foia = FOIARequestFactory(composer__status='filed')
composer = foia.composer
request = self.request_factory.get(
reverse(
'foia-composer-detail',
kwargs={
'slug': composer.slug,
'idx': composer.pk
}
)
)
request.user = UserFactory()
request = mock_middleware(request)
response = ComposerDetail.as_view()(
request,
slug=composer.slug,
idx=composer.pk,
)
eq_(response.status_code, 302)
eq_(response.url, foia.get_absolute_url())
def test_post(self):
"""Posting data for a crowdfund should create it."""
user = UserFactory(is_staff=True)
name = 'Project Crowdfund'
description = 'A crowdfund'
payment_required = 100
payment_capped = True
date_due = date.today() + timedelta(20)
data = {
'name': name,
'description': description,
'payment_required': payment_required,
'payment_capped': payment_capped,
'date_due': date_due
}
request = self.request_factory.post(self.url, data)
request.user = user
request = mock_middleware(request)
response = self.view(request,
slug=self.project.slug,
pk=self.project.pk)
self.project.refresh_from_db()
eq_(self.project.crowdfunds.count(), 1,
'A crowdfund should be created and added to the project.')
crowdfund = self.project.crowdfunds.first()
eq_(crowdfund.name, name)
eq_(crowdfund.description, description)
expected_payment_required = Decimal(payment_required +
payment_required * .15) / 100
eq_(
crowdfund.payment_required, expected_payment_required,
'Expected payment of %(expected).2f, actually %(actual).2f' % {
'expected': expected_payment_required,
'actual': crowdfund.payment_required
})
eq_(crowdfund.payment_capped, payment_capped)
eq_(crowdfund.date_due, date_due)
eq_(response.status_code, 302)
def test_grant_edit_access(self):
"""Editors should be able to add editors."""
user1 = UserFactory()
user2 = UserFactory()
edit_data = {
"action": "grant_access",
"users": [user1.pk, user2.pk],
"access": "edit",
}
edit_request = self.factory.post(self.foia.get_absolute_url(),
edit_data)
edit_request = mock_middleware(edit_request)
edit_request.user = self.editor
edit_response = Detail.as_view()(
edit_request,
jurisdiction=self.foia.jurisdiction.slug,
jidx=self.foia.jurisdiction.id,
slug=self.foia.slug,
idx=self.foia.id,
)
eq_(edit_response.status_code, 302)
assert_true(
self.foia.has_editor(user1) and self.foia.has_editor(user2))
def test_post_update_composer(self):
"""Test submitting a composer"""
composer = FOIAComposerFactory(
status='started',
user__profile__num_requests=4,
)
agency = AgencyFactory()
data = {
'title': 'Title',
'requested_docs': 'ABC',
'agencies': agency.pk,
'action': 'submit',
}
request = self.request_factory.post(
reverse('foia-draft', kwargs={'idx': composer.pk}),
data,
)
request.user = composer.user
request = mock_middleware(request)
response = UpdateComposer.as_view()(request, idx=composer.pk)
eq_(response.status_code, 302)
composer.refresh_from_db()
ok_(composer.status, 'submitted')
def test_staff_post(self):
"""Staff users should need to provide more information, including an owner."""
staff_user = muckrock.core.factories.UserFactory(is_staff=True)
org_owner = muckrock.core.factories.UserFactory()
org_name = 'Cool Org'
org_max = 3
org_cost = 10000
org_requests = 50
data = {
'name': org_name,
'owner': org_owner.pk,
'max_users': org_max,
'monthly_cost': org_cost,
'monthly_requests': org_requests
}
form = muckrock.organization.forms.StaffCreateForm(data)
ok_(form.is_valid(), '%s' % form.errors)
request = self.request_factory.post(self.url, data)
request = mock_middleware(request)
request.user = staff_user
response = self.create_view(request)
eq_(
response.status_code, 302,
'The user should be redirected to the activation page when creation is successful.'
)
org = muckrock.organization.models.Organization.objects.get(
name=org_name)
ok_(org, 'The organization should be created.')
ok_(not org.active, 'The organization should be inactive.')
eq_(org.owner, org_owner,
'The organization should have an owner assigned to it.')
eq_(org.max_users, org_max,
'The organization should have its max users set.')
eq_(org.monthly_cost, org_cost,
'The organization should have its monthly cost set.')
eq_(org.monthly_requests, org_requests,
'The organization should have its monthly requests set.')
def post(self, data, user=AnonymousUser(), ajax=False):
"""Helper function to post the data as the user."""
# need a unique token for each POST
form = CrowdfundPaymentForm(data)
ok_(form.is_valid(), form.errors)
if ajax:
request = self.request_factory.post(
self.url, data=data, HTTP_X_REQUESTED_WITH='XMLHttpRequest')
else:
request = self.request_factory.post(self.url, data=data)
request = mock_middleware(request)
request.user = user
response = self.view(request, pk=self.crowdfund.pk)
ok_(response, 'There should be a response.')
if ajax:
eq_(
response.status_code,
200,
response.content,
)
eq_(
response['Content-Type'],
'application/json',
response.content,
)
else:
eq_(
response.status_code,
302,
response.content,
)
eq_(
response.url,
self.crowdfund.get_crowdfund_object().get_absolute_url(),
response.content,
)
return response
def test_post_ok(self):
"""
Regular users should be able to activate an org.
When doing so, they should be made the owner.
"""
regular_user = muckrock.core.factories.UserFactory()
org_name = 'Cool Org'
data = {'name': org_name}
form = muckrock.organization.forms.CreateForm(data)
ok_(form.is_valid(), '%s' % form.errors)
request = self.request_factory.post(self.url, data)
request = mock_middleware(request)
request.user = regular_user
response = self.create_view(request)
org = muckrock.organization.models.Organization.objects.get(
name=org_name)
ok_(org, 'The organization should be created.')
ok_(not org.active, 'The organization should be inactive.')
eq_(org.owner, regular_user,
'The user should be made the owner of the organization.')
eq_(
response.status_code, 302,
'The user should be redirected to the activation page when creation is successful.'
)
def test_nonexistant_user(self):
"""Buying requests for nonexistant user should return a 404."""
post_request = self.factory.post(self.url, self.data)
post_request = mock_middleware(post_request)
post_request.user = self.user
self.view(post_request, username='******')
def test_get_question_index(self):
"""Get the question index view"""
request = RequestFactory().get(reverse("question-index"))
request = mock_middleware(request)
response = QuestionList.as_view()(request)
nose.tools.eq_(response.status_code, 200)
