def test_post_enable(self):
"""Posting enable should turn on link sharing."""
data = {'action': 'enable'}
http_post_response(self.url, self.view, data, self.foi.user,
**self.kwargs)
self.foi.refresh_from_db()
ok_(self.foi.sharing_code)
def test_add_tags(self):
"""Posting a collection of tags to a request should update its tags."""
data = {'action': 'tags', 'tags': 'foo, bar'}
http_post_response(self.url, self.view, data, self.foia.user, **self.kwargs)
self.foia.refresh_from_db()
ok_('foo' in [tag.name for tag in self.foia.tags.all()])
ok_('bar' in [tag.name for tag in self.foia.tags.all()])
def test_post_status(self):
"""A user updating the status of their request should update the status,
open a status change task, and close any open response tasks"""
nose.tools.assert_not_equal(self.foia.status, 'done')
eq_(
len(
StatusChangeTask.objects.filter(
foia=self.foia,
user=self.foia.user,
resolved=False,
)), 0)
communication = FOIACommunicationFactory(foia=self.foia)
response_task = ResponseTaskFactory(
communication=communication,
resolved=False,
)
data = {'action': 'status', 'status': 'done'}
http_post_response(self.url, self.view, data, self.foia.user,
**self.kwargs)
self.foia.refresh_from_db()
eq_(self.foia.status, 'done')
eq_(
len(
StatusChangeTask.objects.filter(
foia=self.foia,
user=self.foia.user,
resolved=False,
)), 1)
response_task.refresh_from_db()
ok_(response_task.resolved)
def test_settings_view(self):
"""Test the account settings view"""
profile = self.user.profile
profile_data = {
'action': 'profile',
'first_name': 'Allan',
'last_name': 'Lasser',
'twitter': 'allanlasser'
}
email_data = {
'action': 'email',
'email': '*****@*****.**',
'email_pref': 'hourly'
}
settings_url = reverse('acct-settings')
http_post_response(settings_url, views.profile_settings, profile_data,
self.user)
http_post_response(settings_url, views.profile_settings, email_data,
self.user)
self.user.refresh_from_db()
profile.refresh_from_db()
all_data = {}
all_data.update(profile_data)
all_data.update(email_data)
all_data.pop('action')
for key, val in all_data.iteritems():
if key in ['first_name', 'last_name', 'email']:
eq_(val, getattr(self.user, key))
else:
eq_(val, getattr(profile, key))
def test_mark_all_read(self):
"""Users should be able to mark all their notifications as read."""
data = {'action': 'mark_all_read'}
ok_(self.unread_notification.read is not True)
http_post_response(self.url, self.view, data, self.user)
self.unread_notification.refresh_from_db()
ok_(self.unread_notification.read is True,
'The unread notification should be marked as read.')
def test_post_disable(self):
"""Posting disable should turn off link sharing."""
self.foi.generate_sharing_code()
ok_(self.foi.sharing_code)
data = {'action': 'disable'}
http_post_response(self.url, self.view, data, self.foi.user,
**self.kwargs)
self.foi.refresh_from_db()
ok_(not self.foi.sharing_code)
def test_add_projects(self):
"""Posting a collection of projects to a request should add it to those projects."""
project = ProjectFactory()
form = ProjectManagerForm({'projects': [project.pk]})
ok_(form.is_valid())
data = {'action': 'projects'}
data.update(form.data)
http_post_response(self.url, self.view, data, self.foia.user, **self.kwargs)
project.refresh_from_db()
ok_(self.foia in project.requests.all())
def test_appeal_example(self):
"""If an example appeal is used to base the appeal off of,
then the examples should be recorded to the appeal object as well."""
example_appeal = ExampleAppealFactory()
data = {'action': 'appeal', 'text': 'Lorem ipsum', 'base_language': example_appeal.pk}
http_post_response(self.url, self.view, data, self.foia.user, **self.kwargs)
self.foia.refresh_from_db()
appeal = Appeal.objects.last()
ok_(appeal.base_language, 'The appeal should record its base language.')
ok_(appeal.base_language.count(), 1)
def test_post_resolve_task(self):
data = {'resolve': 'truthy', 'task': self.task.pk}
http_post_response(self.url, self.view, data, self.user)
self.task.refresh_from_db()
eq_(
self.task.resolved, True,
'Tasks should be resolved by posting the task ID with a "resolve" request.'
)
eq_(self.task.resolved_by, self.user,
'Task should record the logged in user who resolved it.')
def test_missing_appeal(self):
"""An appeal that is missing its language should not do anything."""
comm_count = self.foia.communications.count()
previous_status = self.foia.status
data = {'action': 'appeal', 'text': ''}
http_post_response(self.url, self.view, data, self.foia.user, **self.kwargs)
self.foia.refresh_from_db()
eq_(self.foia.status, previous_status,
'The status of the request should not be changed.')
eq_(self.foia.communications.count(), comm_count,
'No communication should be added to the request.')
def test_post_set_price(self):
"""Setting the price should update the price on the response's request."""
price = 1
foia = self.task.communication.foia
logging.info(foia.agency)
data = {'status': 'done', 'price': price, 'task': self.task.pk}
http_post_response(self.url, self.view, data, self.user)
self.task.refresh_from_db()
foia.refresh_from_db()
eq_(foia.price, float(price), 'The price on the FOIA should be set.')
ok_(self.task.resolved, 'Setting the price should resolve the task.')
def test_buy_multiple_bundles(self):
"""Users should be able to buy multiple bundles of four requests."""
profile = self.user.profile
bundles_to_buy = 2
existing_request_count = profile.num_requests
self.data['bundles'] = bundles_to_buy
http_post_response(self.url, self.view, self.data, self.user,
**self.kwargs)
profile.refresh_from_db()
requests_to_add = bundles_to_buy * self.user.profile.bundled_requests()
eq_(profile.num_requests, existing_request_count + requests_to_add)
def test_unauthorized_appeal(self):
"""Appealing a request without permission should not do anything."""
unauth_user = UserFactory()
comm_count = self.foia.communications.count()
previous_status = self.foia.status
data = {'action': 'appeal', 'text': 'Lorem ipsum'}
http_post_response(self.url, self.view, data, unauth_user, **self.kwargs)
self.foia.refresh_from_db()
eq_(self.foia.status, previous_status,
'The status of the request should not be changed.')
eq_(self.foia.communications.count(), comm_count,
'No communication should be added to the request.')
def test_batch_resolve_tasks(self):
data = {
'resolve': 'truthy',
'tasks': [_task.id for _task in self.tasks]
}
http_post_response(self.url, self.view, data, self.user)
for _task in self.tasks:
_task.refresh_from_db()
eq_(
_task.resolved, True,
'Task %d should be resolved when doing a batched resolve' %
_task.pk)
def test_unappealable_request(self):
"""An appeal on a request that cannot be appealed should not do anything."""
self.foia.status = 'submitted'
self.foia.save()
nose.tools.assert_false(self.foia.has_perm(self.foia.user, 'appeal'))
comm_count = self.foia.communications.count()
previous_status = self.foia.status
data = {'action': 'appeal', 'text': 'Lorem ipsum'}
http_post_response(self.url, self.view, data, self.foia.user, **self.kwargs)
self.foia.refresh_from_db()
eq_(self.foia.status, previous_status,
'The status of the request should not be changed.')
eq_(self.foia.communications.count(), comm_count,
'No communication should be added to the request.')
def test_post_move(self):
"""Moving the response should save it to a new request."""
other_foia = factories.FOIARequestFactory()
starting_date = self.task.communication.date
data = {'move': other_foia.id, 'status': 'done', 'task': self.task.pk}
http_post_response(self.url, self.view, data, self.user)
self.task.refresh_from_db()
self.task.communication.refresh_from_db()
ending_date = self.task.communication.date
eq_(self.task.communication.foia, other_foia,
'The response should be moved to a different FOIA.')
ok_(self.task.resolved, 'Moving the status should resolve the task')
eq_(starting_date, ending_date,
'Moving the communication should not change its date.')
def test_appeal(self):
"""Appealing a request should send a new communication,
record the details of the appeal, and update the status of the request."""
comm_count = self.foia.communications.count()
data = {'action': 'appeal', 'text': 'Lorem ipsum'}
http_post_response(self.url, self.view, data, self.foia.user, **self.kwargs)
self.foia.refresh_from_db()
eq_(self.foia.status, 'appealing')
eq_(self.foia.communications.count(), comm_count + 1)
eq_(self.foia.last_comm().communication, data['text'],
'The appeal should use the language provided by the user.')
appeal = Appeal.objects.last()
ok_(appeal, 'An Appeal object should be created.')
eq_(self.foia.last_comm(), appeal.communication,
'The appeal should reference the communication that was created.')
def test_add_contributors(self, mock_notify):
"""When adding contributors, each new contributor should get an email notification."""
new_contributor = factories.UserFactory()
data = {
'title': self.project.title,
'contributors': [self.contributor.pk, new_contributor.pk]
}
form = forms.ProjectUpdateForm(data, instance=self.project)
ok_(form.is_valid(), 'The form should validate. %s' % form.errors)
http_post_response(self.url, self.view, data, self.contributor,
**self.kwargs)
self.project.refresh_from_db()
ok_(self.project.has_contributor(new_contributor))
ok_(self.project.has_contributor(self.contributor))
mock_notify.assert_called_once_with(new_contributor, self.project,
self.contributor)
def test_add_note(self):
"""User with edit permission should be able to create a note."""
response = http_post_response(self.url, self.view, self.data,
self.editor, **self.kwargs)
self.foia.refresh_from_db()
eq_(response.status_code, 302)
eq_(self.foia.notes.count() > 0, True)
def test_add_sans_permission(self):
"""Normies and viewers cannot add notes."""
response = http_post_response(self.url, self.view, self.data,
self.viewer, **self.kwargs)
self.foia.refresh_from_db()
eq_(response.status_code, 302)
eq_(self.foia.notes.count(), 0)
def test_downgrade(self, mock_unsubscribe):
"""Logged in pro users should be able to downgrade to a Basic account."""
data = {'action': 'downgrade'}
pro_user = UserFactory(profile__acct_type='pro')
response = http_post_response(self.url, self.view, data, pro_user)
eq_(response.status_code, 200)
ok_(mock_unsubscribe.called)
def test_post_ok(self):
"""Logging in should redirect to the profile page."""
data = {
'username': self.user.username,
'password': self.password,
}
response = http_post_response(self.url, self.view, data)
eq_(response.status_code, 200)
def test_logged_out_post(self, mock_subscribe):
"""Posting valid data while logged out should create a new professional account."""
response = http_post_response(self.url, self.view, self.data)
eq_(response.status_code, 302,
'Should redirect to the new account upon creation.')
user = User.objects.get(username=self.data['username'])
ok_(user, 'The user should be created.')
ok_(mock_subscribe.called_once)
def test_edit_description(self):
"""
The description should be editable.
When sending data, the 'edit' keyword should be set to 'description'.
"""
desc = 'Lorem ipsum'
data = {
'title': self.project.title,
'description': desc,
}
form = forms.ProjectUpdateForm(data, instance=self.project)
ok_(form.is_valid(), 'The form should validate. %s' % form.errors)
http_post_response(self.url, self.view, data, self.contributor,
**self.kwargs)
self.project.refresh_from_db()
eq_(self.project.description, desc,
'The description should be updated.')
def test_logged_out_post(self):
"""Posting valid data while logged out should create a new basic account."""
response = http_post_response(self.url, self.view, self.data)
eq_(response.status_code, 302,
'Should redirect to the new account upon creation.')
user = User.objects.get(username=self.data['username'])
ok_(user, 'The user should be created.')
eq_(user.profile.acct_type, 'basic',
'The user should be given a basic plan.')
def test_post_tracking_number(self):
"""Setting the tracking number should save it to the response's request."""
new_tracking_id = 'ABC123OMGWTF'
data = {
'tracking_number': new_tracking_id,
'status': 'done',
'task': self.task.pk
}
http_post_response(self.url, self.view, data, self.user)
self.task.refresh_from_db()
self.task.communication.refresh_from_db()
self.task.communication.foia.refresh_from_db()
foia_tracking = self.task.communication.foia.tracking_id
eq_(
foia_tracking, new_tracking_id,
'The new tracking number should be saved to the associated request.'
)
ok_(self.task.resolved,
'Setting the tracking number should resolve the task')
def test_logged_out_post(self):
"""Posting valid data while logged out should create a new professional account."""
response = http_post_response(self.url, self.view, self.data)
eq_(response.status_code, 302,
'Should redirect to the org activation page upon creation.')
user = User.objects.get(username=self.data['username'])
org = Organization.objects.get(name=self.data['organization_name'])
ok_(user, 'The user should be created.')
ok_(org, 'The org should be created.')
eq_(org.owner, user, 'The user should be made an owner of the org.')
def test_terrible_data(self):
"""Posting awful data shouldn't cause everything to collapse."""
data = {
'move': 'omglol, howru',
'status': 'notastatus',
'tracking_number': ['wtf'],
'task': self.task.pk
}
response = http_post_response(self.url, self.view, data, self.user)
ok_(response)
def test_post_view(self, mock_subscribe):
"""Posting an email to the list should add that email to our MailChimp list."""
form = NewsletterSignupForm({
'email': '*****@*****.**',
'list': settings.MAILCHIMP_LIST_DEFAULT
})
ok_(form.is_valid(), 'The form should validate.')
response = http_post_response(self.url, self.view, form.data)
mock_subscribe.assert_called_with(form.data['email'], form.data['list'])
eq_(response.status_code, 302, 'Should redirect upon successful submission.')
def test_post(self, mock_publish):
"""Posting a valid ProjectPublishForm should publish the project."""
notes = 'Testing project publishing'
form = forms.ProjectPublishForm({'notes': notes})
ok_(form.is_valid(), 'The form should validate.')
response = http_post_response(self.url, self.view, form.data,
self.contributor, **self.kwargs)
eq_(response.status_code, 302, 'The user should be redirected.')
eq_(response.url, self.project.get_absolute_url(),
'The user should be redirected back to the project page.')
mock_publish.assert_called_with(notes)
