def test_one_result_in_correct_org(self):
"""
Test content of search page context for when a search
yields a single result, but only because all but one
of the matching decisions are in an organization that
we are not looking in.
"""
decision = DecisionFactory(organization=self.org)
other_org = OrganizationFactory()
for _ in range(100):
other_decision = DecisionFactory(organization=other_org)
response = self.do_search_request(q='aardvark')
context = response.context_data
self.assertEqual(context.get('tab'), 'search')
self.assertEqual('aardvark', context.get('query'))
self.assertEqual(self.org, context.get('organization'))
self.assertTrue(context.get('page'))
page = context.get('page')
self.assertEqual(1, len(page.object_list))
self.assertFalse(page.has_previous())
self.assertFalse(page.has_next())
self.assertEquals(1, page.number)
self.assertEquals(1, page.paginator.num_pages)
def test_middle_page_with_nondefault_items_per_page(self):
"""
Test content of search page context for when a search
yields results that must be split across three pages.
To make things more interesting, we are not using
the default number of items per page, and we are asking
for the second of the pages.
"""
for _ in range(75):
decision = DecisionFactory(organization=self.org)
response = self.do_search_request(q='aardvark', num='25', page='2')
context = response.context_data
self.assertEqual(context.get('tab'), 'search')
self.assertEqual('25', context.get('num'))
self.assertEqual('aardvark', context.get('query'))
self.assertEqual(self.org, context.get('organization'))
page = context.get('page')
self.assertEqual(25, len(page.object_list))
self.assertTrue(page.has_previous())
self.assertTrue(page.has_next())
self.assertEquals(2, page.number)
self.assertEquals(3, page.paginator.num_pages)
self.assertEquals("?q=aardvark&num=25", context.get("queryurl"))
def setUp(self):
mail.outbox = []
self.user = UserFactory(email="*****@*****.**")
decision = DecisionFactory(author=self.user)
feedbackAuthor = UserFactory(email="*****@*****.**")
self.feedback = FeedbackFactory(decision=decision,
description="Not so fast",
author=feedbackAuthor,
editor=feedbackAuthor)
def setUp(self):
user = UserFactory()
self.decision = DecisionFactory(author=user, description="Eat Cheese")
watcher = UserFactory(email="*****@*****.**")
organization = self.decision.organization
self.settings = NotificationSettingsFactory(
user=watcher,
organization=organization,
notification_level=FEEDBACK_ADDED_NOTIFICATIONS)
OrganizationUserFactory(user=watcher, organization=organization)
def test_status_is_set_in_context_data_and_limits_object_list(self):
"""
More integrated test, that goes through dispatch, get, and
get_context_data method to get the response object and test it.
"""
decision = DecisionFactory(status=Decision.DECISION_STATUS)
org = decision.organization
archive = DecisionFactory(organization=org,
status=Decision.ARCHIVED_STATUS)
kwargs = {'org_slug': org.slug, 'status': archive.status}
request = RequestFactory().get('/')
request.user = UserFactory.build()
request.session = {}
response = DecisionList.as_view()(request, **kwargs)
self.assertIn('tab', response.context_data.keys())
self.assertEqual(response.context_data['tab'], archive.status)
self.assertIn(archive, response.context_data['object_list'])
self.assertNotIn(decision, response.context_data['object_list'])
def test_decision_last_status_set_on_update_via_admin(self):
status = Decision.DECISION_STATUS
user = UserFactory()
decision = DecisionFactory(author=user,
editor=user,
description="Lorem",
status=status)
self.assertEquals(decision.last_status, 'new')
self.login_admin_user()
self.change_decision_via_admin(decision)
decision = Decision.objects.get(id=decision.id)
self.assertEqual(decision.last_status, status)
def test_decision_editor_set_on_update_via_admin(self):
user = UserFactory(username='******')
decision = DecisionFactory(author=user,
editor=user,
description="Lorem Ipsum")
new_organization = OrganizationFactory()
admin_user = self.login_admin_user()
self.change_decision_via_admin(decision, new_organization)
decision = Decision.objects.get(id=decision.id)
self.assertEquals(decision.editor, admin_user)
def test_feedback_author_is_assigned_on_feedback_create(self):
decision = DecisionFactory()
user = UserFactory()
request = RequestFactory()
request.user = user
feedback_create_view = FeedbackCreate()
feedback_create_view.request = request
feedback_create_view.kwargs = {'parent_pk': decision.id}
form = FeedbackForm()
form.cleaned_data = {}
feedback_create_view.form_valid(form)
feedback = decision.feedback_set.get()
self.assertEqual(feedback.author, user)
def setUp(self):
mail.outbox = []
self.user = UserFactory(email="*****@*****.**")
decision = DecisionFactory(author=self.user)
feedbackAuthor = UserFactory(email="*****@*****.**")
self.feedback = FeedbackFactory(decision=decision,
description="Not so fast",
author=feedbackAuthor,
editor=feedbackAuthor)
organization = decision.organization
self.settings = NotificationSettingsFactory(
user=self.user,
organization=organization,
notification_level=FEEDBACK_MAJOR_CHANGES)
OrganizationUserFactory(user=self.user, organization=organization)
def setUp(self):
self.user = UserFactory()
self.decision = DecisionFactory()
# Ensure value of "now" always increases by amount sufficient
# to show up as a change, even if db resolution for datetime
# is one second.
def now_iter(start):
t = start
while True:
t += datetime.timedelta(hours=1)
yield t
minimock.mock("timezone.now",
returns_iter=now_iter(timezone.now()),
tracker=None)
def test_decision_editor_set_on_update(self):
# Create the decision
user1 = UserFactory()
decision = DecisionFactory(author=user1, editor=user1)
# Have a different user update it
user2 = UserFactory()
request = RequestFactory()
request.user = user2
decision_update_view = DecisionUpdate()
decision_update_view.request = request
decision_update_view.object = decision
decision_update_view.get_object = lambda: decision
decision_update_view.last_status = 'dummy'
form = DecisionForm(instance=decision)
form.cleaned_data = {'watch': True}
decision_update_view.form_valid(form)
self.assertEqual(decision.editor, user2)
def test_active_users_of_org_added_to_watchers_of_new_decision(self):
"""
See no reason to have this in a view test, this behavior is almost
entirely tested already in the model tests in tests/decisions_test.py
Suggest, moving this test to there.
"""
org = OrganizationFactory()
active_org_user1 = OrganizationUserFactory(organization=org)
active_org_user2 = OrganizationUserFactory(organization=org)
inactive_org_user = OrganizationUserFactory(
user=UserFactory(is_active=False), organization=org)
active_other_org_user = OrganizationUserFactory()
decision = DecisionFactory(organization=org)
watching_user_ids = decision.watchers.values_list('user_id', flat=True)
self.assertIn(active_org_user1.user.id, watching_user_ids)
self.assertIn(active_org_user2.user.id, watching_user_ids)
self.assertEqual(len(watching_user_ids), 2)
def test_decision_last_status_set_on_update(self):
status = Decision.DECISION_STATUS
user = UserFactory()
decision = DecisionFactory(author = user,
editor = user,
description = 'Lorem',
status = status)
self.assertEquals(decision.last_status, 'new')
request = RequestFactory().get('/')
assign_perm('edit_decisions_feedback', user, decision.organization)
request.user = user
request.method = 'POST'
request.POST = {'status': decision.status, 'description': decision.description}
kwargs = {'pk': decision.id}
DecisionUpdate.as_view()(request, **kwargs)
decision = Decision.objects.get(id=decision.id)
self.assertEqual(decision.last_status, status)
def test_send_notifications_for_main_items_sends_correct_messages(self):
initial_count = len(mail.outbox)
number_of_users = 3
organization = OrganizationFactory()
decision = DecisionFactory(organization=organization)
decision = add_watchers(decision)
user1, user2, user3 = UserFactory.create_batch(number_of_users,
email="*****@*****.**")
NotificationSettingsFactory(user=user1,
organization=organization,
notification_level=NO_NOTIFICATIONS),
NotificationSettingsFactory(
user=user2,
organization=organization,
notification_level=MAIN_ITEMS_NOTIFICATIONS_ONLY),
NotificationSettingsFactory(
user=user3,
organization=organization,
notification_level=MINOR_CHANGES_NOTIFICATIONS),
settings_handler = ObservationManager()
recipients = [user1, user2, user3]
settings_handler.send_notifications(
recipients, decision, DECISION_NEW, {"observed": decision}, {
'Message-ID': decision.get_message_id(),
'Precedence': 'bulk',
'Auto-Submitted': 'auto-generated'
}, "*****@*****.**")
final_count = len(mail.outbox)
expected_number_messages_sent = len(
decision.watchers.all()) + number_of_users - 1
actual_number_messages_sent = final_count - initial_count
self.assertEqual(expected_number_messages_sent,
actual_number_messages_sent)
def test_user_can_unwatch_a_decision(self):
org_user = OrganizationUserFactory()
org = org_user.organization
user = org_user.user
decision = DecisionFactory(organization=org)
# Confirm decision has a single watcher
self.assertEqual(decision.watchers.count(), 1)
# Get the view ready
request = RequestFactory()
request.user = user
decision_update_view = DecisionUpdate()
decision_update_view.request = request
decision_update_view.object = decision
decision_update_view.get_object = lambda: decision
decision_update_view.last_status = 'dummy'
form = DecisionForm(instance=decision)
form.cleaned_data = {'watch': False}
# Run the form_valid method to stop observing
decision_update_view.form_valid(form)
self.assertEqual(decision.watchers.count(), 0)
def test_one_result(self):
"""
Test content of search page context for when a search
yields a single result.
"""
decision = DecisionFactory(organization=self.org)
response = self.do_search_request(q='aardvark')
context = response.context_data
self.assertEqual(context.get('tab'), 'search')
self.assertEqual('aardvark', context.get('query'))
self.assertEqual(self.org, context.get('organization'))
self.assertTrue(context.get('page'))
page = context.get('page')
self.assertEqual(1, len(page.object_list))
self.assertFalse(page.has_previous())
self.assertFalse(page.has_next())
self.assertEquals(1, page.number)
self.assertEquals(1, page.paginator.num_pages)
def test_more_than_one_page(self):
"""
Test content of search page context for when a search
yields results that must be split across two pages.
"""
for _ in range(20):
decision = DecisionFactory(organization=self.org)
response = self.do_search_request(q='aardvark')
context = response.context_data
self.assertEqual(context.get('tab'), 'search')
self.assertEqual('10', context.get('num'))
self.assertEqual('aardvark', context.get('query'))
self.assertEqual(self.org, context.get('organization'))
page = context.get('page')
self.assertEqual(10, len(page.object_list))
self.assertFalse(page.has_previous())
self.assertTrue(page.has_next())
self.assertEquals(1, page.number)
self.assertEquals(2, page.paginator.num_pages)
self.assertEquals("?q=aardvark", context.get("queryurl"))
def test_active_users_of_org_added_to_watchers_of_new_decision(self):
"""
See no reason to have this in a view test, this behavior is almost
entirely tested already in the model tests in tests/decisions_test.py
Suggest, moving this test to there.
"""
org_user_factory = OrganizationUserFactory()
org = org_user_factory.organization
user_in_org = org_user_factory.user
UserFactory() # Create one user not linked to the org for completeness
user_inactive = UserFactory(is_active=False)
# Link the inactive user with the existing org and confirm it worked
OrganizationUserFactory(user=user_inactive, organization=org)
user_status_list = [user.user.is_active
for user in org.organization_users.all()]
assert user_status_list.count(True) == 1
assert user_status_list.count(False) == 1
# The Test
decision = DecisionFactory(organization=org)
self.assertEqual(decision.watchers.count(), 1,
"There should be one watcher.")
self.assertEqual(decision.watchers.get().user, user_in_org,
"The watcher user should be the active user.")
def setUp(self):
user = UserFactory()
self.decision = DecisionFactory(author=user, description="Eat Cheese")
watcher = UserFactory(email="*****@*****.**")
notification.observe(self.decision, watcher, 'decision_change')
def setUp(self):
self.user = UserFactory()
self.decision = DecisionFactory()
