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_normal(self):
"""Test a normal succesful response"""
foia = FOIARequestFactory(status="ack")
from_name = "Smith, Bob"
from_email = "*****@*****.**"
from_ = '"%s" <%s>' % (from_name, from_email)
to_ = '%s, "Doe, John" <*****@*****.**>' % foia.get_request_email()
subject = "Test subject"
text = "Test normal."
signature = "-Charlie Jones"
self.mailgun_route(from_, to_, subject, text, signature)
foia.refresh_from_db()
last_comm = foia.communications.last()
nose.tools.eq_(last_comm.communication, "%s\n%s" % (text, signature))
nose.tools.eq_(last_comm.subject, subject)
nose.tools.eq_(last_comm.from_user, foia.agency.get_user())
nose.tools.eq_(last_comm.to_user, foia.user)
nose.tools.eq_(last_comm.response, True)
nose.tools.eq_(last_comm.full_html, False)
nose.tools.ok_(last_comm.get_raw_email())
nose.tools.eq_(last_comm.responsetask_set.count(), 1)
nose.tools.eq_(foia.email, EmailAddress.objects.fetch(from_email))
nose.tools.eq_(
set(foia.cc_emails.all()),
set(EmailAddress.objects.fetch_many("*****@*****.**")),
)
nose.tools.eq_(foia.status, "processed")
def test_clone_multi(self, mock_upload):
"""Should duplicate the communication to each request in the list."""
first_foia = FOIARequestFactory()
second_foia = FOIARequestFactory()
third_foia = FOIARequestFactory()
comm_count = FOIACommunication.objects.count()
clones = self.comm.clone(
[first_foia, second_foia, third_foia],
self.user,
)
# + 3 communications
eq_(
FOIACommunication.objects.count(), comm_count + 3,
'Should clone the request twice.'
)
ok_(
clones[0].pk is not clones[1].pk is not clones[2].pk,
'The returned list should contain unique communcation objects.'
)
# a move log should be generated for each cloned request
for clone in clones:
ok_(
CommunicationMoveLog.objects.filter(
communication=clone,
foia=self.comm.foia,
user=self.user,
).exists()
)
mock_upload.assert_called()
def test_foia_followup_estimated(self):
"""If request has an estimated date, returns number of days until the estimated date"""
# pylint: disable=protected-access
num_days = 365
foia = FOIARequestFactory(date_estimate=date.today() +
timedelta(num_days))
nose.tools.eq_(foia._followup_days(), num_days)
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_foia_list_user(self):
"""Test the foia-list-user view"""
users = UserFactory.create_batch(2)
FOIARequestFactory.create_batch(4, composer__user=users[0])
FOIARequestFactory.create_batch(3, composer__user=users[1])
for user in users:
response = get_allowed(
self.client,
reverse('foia-list-user', kwargs={
'user_pk': user.pk,
})
)
nose.tools.eq_(
set(response.context['object_list']),
set(
FOIARequest.objects.get_viewable(AnonymousUser())
.filter(composer__user=user)
)
)
nose.tools.ok_(
all(
foia.user == user
for foia in response.context['object_list']
)
)
def test_bad_verify(self):
"""Test an improperly signed message"""
foia = FOIARequestFactory(block_incoming=True)
to_ = foia.get_request_email()
response = self.mailgun_route(to_=to_, sign=False)
nose.tools.eq_(response.status_code, 403)
def setUp(self):
"""Set up tests"""
mail.outbox = []
self.foia = FOIARequestFactory(status='submitted', title='Test 1')
UserFactory(username='******')
def setUp(self):
self.foia1 = FOIARequestFactory()
self.foia2 = FOIARequestFactory()
self.comm = FOIACommunicationFactory(foia=self.foia1)
self.file = FOIAFileFactory(comm=self.comm)
eq_(self.comm.files.count(), 1)
self.user = UserFactory()
def setUp(self):
"""Set up tests"""
mail.outbox = []
self.foia = FOIARequestFactory(status="submitted", title="Test 1")
UserFactory(username="******")
def setUp(self):
agency = AgencyFactory()
self.owner = UserFactory()
self.follower = UserFactory()
self.request = FOIARequestFactory(composer__user=self.owner,
agency=agency)
follow(self.follower, self.request)
self.action = new_action(agency, "completed", target=self.request)
def setUp(self):
self.foia = FOIARequestFactory(status='payment')
self.url = reverse('foia-crowdfund',
args=(self.foia.jurisdiction.slug,
self.foia.jurisdiction.id, self.foia.slug,
self.foia.id))
self.request_factory = RequestFactory()
self.view = crowdfund_request
def test_foia_viewable(self):
"""Test all the viewable and embargo functions"""
user1 = UserFactory()
user2 = UserFactory()
foias = [
FOIARequestFactory(
composer__user=user1,
status='done',
embargo=False,
),
FOIARequestFactory(
composer__user=user1,
status='done',
embargo=True,
),
FOIARequestFactory(
composer__user=user1,
status='done',
embargo=True,
),
]
foias[2].add_viewer(user2)
# check manager get_viewable against view permission
viewable_foias = FOIARequest.objects.get_viewable(user1)
for foia in FOIARequest.objects.all():
if foia in viewable_foias:
nose.tools.assert_true(foia.has_perm(user1, 'view'))
else:
nose.tools.assert_false(foia.has_perm(user1, 'view'))
viewable_foias = FOIARequest.objects.get_viewable(user2)
for foia in FOIARequest.objects.all():
if foia in viewable_foias:
nose.tools.assert_true(foia.has_perm(user2, 'view'))
else:
nose.tools.assert_false(foia.has_perm(user2, 'view'))
viewable_foias = FOIARequest.objects.get_public()
for foia in FOIARequest.objects.all():
if foia in viewable_foias:
nose.tools.assert_true(foia.has_perm(AnonymousUser(), 'view'))
else:
nose.tools.assert_false(foia.has_perm(AnonymousUser(), 'view'))
nose.tools.assert_true(foias[0].has_perm(user1, 'view'))
nose.tools.assert_true(foias[1].has_perm(user1, 'view'))
nose.tools.assert_true(foias[2].has_perm(user1, 'view'))
nose.tools.assert_true(foias[0].has_perm(user2, 'view'))
nose.tools.assert_false(foias[1].has_perm(user2, 'view'))
nose.tools.assert_true(foias[2].has_perm(user2, 'view'))
nose.tools.assert_true(foias[0].has_perm(AnonymousUser(), 'view'))
nose.tools.assert_false(foias[1].has_perm(AnonymousUser(), 'view'))
nose.tools.assert_false(foias[2].has_perm(AnonymousUser(), 'view'))
class TestCommunication(test.TestCase):
"""Tests communication methods"""
def setUp(self):
self.foia = FOIARequestFactory()
self.comm = FOIACommunicationFactory(
foia=self.foia,
email__from_email=EmailAddress.objects.
fetch(u'Test Email <*****@*****.**>'),
)
self.file = FOIAFileFactory(comm=self.comm)
eq_(self.comm.files.count(), 1)
def test_primary_contact(self):
"""Makes the primary email of the FOIA to the email the communication was sent from."""
self.comm.make_sender_primary_contact()
self.foia.refresh_from_db()
eq_(self.foia.email, self.comm.emails.first().from_email)
def test_attach_file_with_file(self):
"""Test attaching a file with an actual file"""
comm = FOIACommunicationFactory()
file_ = open('tmp.txt', 'w')
file_.write('The file contents')
file_.close()
file_ = open('tmp.txt', 'r')
comm.attach_file(file_=file_)
file_.close()
os.remove('tmp.txt')
eq_(comm.files.count(), 1)
foia_file = comm.files.first()
eq_(foia_file.title, 'tmp')
eq_(foia_file.ffile.file.name, 'tmp.txt')
eq_(foia_file.ffile.read(), 'The file contents')
def test_attach_file_with_content(self):
"""Test attaching a file with n memory content"""
comm = FOIACommunicationFactory()
comm.attach_file(content='More contents', name='doc.pdf')
eq_(comm.files.count(), 1)
foia_file = comm.files.first()
eq_(foia_file.title, 'doc')
eq_(foia_file.ffile.file.name, 'doc.pdf')
eq_(foia_file.ffile.read(), 'More contents')
@raises(ValueError)
def test_orphan_error(self):
"""Orphans should raise an error"""
self.comm.foia = None
self.comm.make_sender_primary_contact()
@raises(ValueError)
def test_bad_sender_error(self):
"""Comms with bad sender email should raise an error"""
email = self.comm.emails.first()
email.from_email = None
email.save()
self.comm.make_sender_primary_contact()
def test_get_viewable_edit_collaborator(self):
"""Test get viewable for an edit collaborator"""
foia = FOIARequestFactory(composer__status="filed", embargo=True)
foia.add_editor(self.user)
assert_true(FOIAComposer.objects.get_viewable(self.staff).exists())
assert_true(FOIAComposer.objects.get_viewable(self.user).exists())
assert_false(FOIAComposer.objects.get_viewable(self.anon).exists())
def test_get_viewable_partial_embargoed(self):
"""Test get viewable for a partially embargoed composer"""
foia = FOIARequestFactory(composer__status="filed", embargo=True)
FOIARequestFactory(composer=foia.composer, embargo=False)
assert_true(FOIAComposer.objects.get_viewable(self.staff).exists())
assert_true(FOIAComposer.objects.get_viewable(self.user).exists())
assert_true(FOIAComposer.objects.get_viewable(self.anon).exists())
def setUp(self):
self.foia = FOIARequestFactory()
self.comm = FOIACommunicationFactory(
foia=self.foia,
email__from_email=EmailAddress.objects.
fetch(u'Test Email <*****@*****.**>'),
)
self.file = FOIAFileFactory(comm=self.comm)
eq_(self.comm.files.count(), 1)
def test_fee_rate(self):
"""
Jurisdictions should report the rate at which requests have fees.
State jurisdictions should include fee rates of local jurisdictions.
"""
FOIARequestFactory(agency__jurisdiction=self.state, status="ack", price=0)
FOIARequestFactory(agency__jurisdiction=self.local, status="ack", price=1.00)
eq_(self.state.fee_rate(), 50.0)
eq_(self.local.fee_rate(), 100.0)
def test_requests(self):
"""Projects should keep a list of relevant FOIA requests."""
request1 = FOIARequestFactory()
request2 = FOIARequestFactory()
self.project.requests.add(request1, request2)
ok_(request1 in self.project.requests.all())
ok_(request2 in self.project.requests.all())
self.project.articles.clear()
eq_(len(self.project.articles.all()), 0)
def test_multi_clone(self):
"""Test cloning a multirequest"""
foia = FOIARequestFactory(composer__status="filed", embargo=False)
FOIARequestFactory(composer=foia.composer)
form = BaseComposerForm(
{"action": "save", "parent": foia.composer.pk, "tags": ""},
user=foia.composer.user,
request=None,
)
ok_(form.is_valid())
def test_soft_delete(self):
"""Test the soft delete method"""
foia = FOIARequestFactory(status="processed")
FOIAFileFactory.create_batch(size=3, comm__foia=foia)
user = UserFactory(is_superuser=True)
nose.tools.eq_(foia.get_files().count(), 3)
nose.tools.eq_(
RawEmail.objects.filter(email__communication__foia=foia).count(),
3)
foia.soft_delete(user, "final message", "note")
foia.refresh_from_db()
self.run_commit_hooks()
# final communication we send out is not cleared
for comm in list(foia.communications.all())[:-1]:
nose.tools.eq_(comm.communication, "")
nose.tools.eq_(foia.get_files().count(), 0)
# one raw email left on the final outgoing message
nose.tools.eq_(
RawEmail.objects.filter(email__communication__foia=foia).count(),
1)
nose.tools.eq_(foia.last_request().communication, "final message")
nose.tools.eq_(foia.notes.first().note, "note")
nose.tools.ok_(foia.deleted)
nose.tools.ok_(foia.embargo)
nose.tools.ok_(foia.permanent_embargo)
nose.tools.eq_(foia.status, "abandoned")
def test_bad_strip(self):
"""Test an improperly stripped message"""
foia = FOIARequestFactory()
to_ = foia.get_request_email()
text = ""
body = "Here is the full body."
self.mailgun_route(to_=to_, text=text, body=body)
last_comm = foia.communications.last()
nose.tools.eq_(last_comm.communication, body)
def test_success_rate(self):
"""
Jurisdictions should report their success rate: completed/filed.
State jurisdictions should include success rates of local jurisdictions.
"""
FOIARequestFactory(
agency__jurisdiction=self.state, status="done", datetime_done=timezone.now()
)
FOIARequestFactory(agency__jurisdiction=self.local, status="ack")
eq_(self.state.success_rate(), 50.0)
eq_(self.local.success_rate(), 0.0)
def test_move(self):
"""Should move the communication to the listed requests and create a
ResponseTask for each new communication.
"""
foia1 = FOIARequestFactory()
foia2 = FOIARequestFactory()
foia3 = FOIARequestFactory()
count_response_tasks = ResponseTask.objects.count()
self.task.move([foia1.pk, foia2.pk, foia3.pk], self.user)
eq_(ResponseTask.objects.count(), count_response_tasks + 3,
'Reponse tasks should be created for each communication moved.')
def test_reject(self):
replacement = AgencyFactory()
existing_foia = FOIARequestFactory(agency=self.agency)
self.task.reject(replacement)
existing_foia.refresh_from_db()
eq_(self.task.agency.status, 'rejected',
'Rejecting a new agency should leave it unapproved.')
eq_(
existing_foia.agency, replacement,
'The replacement agency should receive the rejected agency\'s requests.'
)
def test_access_key(self):
"""Editors should be able to generate a secure access key to view an embargoed request."""
embargoed_foia = FOIARequestFactory(embargo=True)
access_key = embargoed_foia.generate_access_key()
nose.tools.assert_true(
access_key == embargoed_foia.access_key,
'The key in the URL should match the key saved to the request.')
embargoed_foia.generate_access_key()
nose.tools.assert_false(
access_key == embargoed_foia.access_key,
'After regenerating the link, the key should no longer match.')
def test_get_viewable_read_collaborator(self):
"""Test get viewable for a read collaborator"""
foia = FOIARequestFactory(
composer__status='filed',
embargo=True,
)
foia.add_viewer(self.user)
assert_true(FOIAComposer.objects.get_viewable(self.staff).exists())
assert_true(FOIAComposer.objects.get_viewable(self.user).exists())
assert_false(FOIAComposer.objects.get_viewable(self.anon).exists())
def setUp(self):
self.factory = RequestFactory()
self.foia = FOIARequestFactory()
self.creator = self.foia.user
self.editor = UserFactory()
self.viewer = UserFactory()
self.staff = UserFactory(is_staff=True)
self.normie = UserFactory()
self.foia.add_editor(self.editor)
self.foia.add_viewer(self.viewer)
self.foia.save()
UserFactory(username='******')
def setUp(self):
agency = AgencyFactory(appeal_agency=AppealAgencyFactory())
self.foia = FOIARequestFactory(agency=agency)
self.view = Detail.as_view()
self.url = self.foia.get_absolute_url()
self.kwargs = {
'jurisdiction': self.foia.jurisdiction.slug,
'jidx': self.foia.jurisdiction.id,
'slug': self.foia.slug,
'idx': self.foia.id
}
UserFactory(username='******')
def setUp(self):
agency = AgencyFactory(appeal_agency=AppealAgencyFactory())
self.foia = FOIARequestFactory(agency=agency)
self.view = Detail.as_view()
self.url = self.foia.get_absolute_url()
self.kwargs = {
"jurisdiction": self.foia.jurisdiction.slug,
"jidx": self.foia.jurisdiction.id,
"slug": self.foia.slug,
"idx": self.foia.id,
}
UserFactory(username="******")
