def test_with_case_count_assigned(self):
user = UserFactory()
self.assertEqual(
User.objects.with_case_count_assigned().get(
pk=user.pk).case_assigned_sum, 0)
SIZE_PATTERN = [(1, Case.STATUS.free), (2, Case.STATUS.assigned),
(3, Case.STATUS.closed)]
for size, status in SIZE_PATTERN:
for obj in CaseFactory.create_batch(size=size, status=status):
assign_perm('cases.can_view', user, obj)
user = User.objects.with_case_count_assigned().get(pk=user.pk)
self.assertEqual(user.case_assigned_free, 1)
self.assertEqual(user.case_assigned_active, 2)
self.assertEqual(user.case_assigned_closed, 3)
self.assertEqual(user.case_assigned_sum, 6)
SIZE_PATTERN_UPDATED = [(4, Case.STATUS.free),
(5, Case.STATUS.assigned),
(6, Case.STATUS.closed)]
for size, status in SIZE_PATTERN_UPDATED:
for obj in CaseFactory.create_batch(size=size, status=status):
assign_perm('cases.can_view', user, obj)
user_updated = User.objects.with_case_count_assigned().get(pk=user.pk)
self.assertEqual(user_updated.case_assigned_free, 5)
self.assertEqual(user_updated.case_assigned_active, 7)
self.assertEqual(user_updated.case_assigned_closed, 9)
self.assertEqual(user_updated.case_assigned_sum, 21)
def test_with_case_count(self):
user = UserFactory()
CaseFactory.create_batch(size=25, client=user)
self.assertEqual(User.objects.with_case_count().get(pk=user.pk).case_count, 25)
self.assertEqual(
User.objects.with_case_count().get(pk=UserFactory().pk).case_count, 0
)
def test_closed_to_free(self):
case = CaseFactory(pk=639, status=Case.STATUS.closed)
message = self.get_message('cc_message.eml')
mail_process(sender=self.mailbox, message=message)
case.refresh_from_db()
self.assertEqual(case.status, Case.STATUS.free)
def test_with_case_count_assigned(self):
user = UserFactory()
self.assertEqual(User.objects.with_case_count_assigned().get(
pk=user.pk).case_assigned_sum, 0)
SIZE_PATTERN = [(1, Case.STATUS.free),
(2, Case.STATUS.assigned),
(3, Case.STATUS.closed)]
for size, status in SIZE_PATTERN:
for obj in CaseFactory.create_batch(size=size, status=status):
assign_perm('cases.can_view', user, obj)
user = User.objects.with_case_count_assigned().get(pk=user.pk)
self.assertEqual(user.case_assigned_free, 1)
self.assertEqual(user.case_assigned_active, 2)
self.assertEqual(user.case_assigned_closed, 3)
self.assertEqual(user.case_assigned_sum, 6)
SIZE_PATTERN_UPDATED = [(4, Case.STATUS.free),
(5, Case.STATUS.assigned),
(6, Case.STATUS.closed)]
for size, status in SIZE_PATTERN_UPDATED:
for obj in CaseFactory.create_batch(size=size, status=status):
assign_perm('cases.can_view', user, obj)
user_updated = User.objects.with_case_count_assigned().get(pk=user.pk)
self.assertEqual(user_updated.case_assigned_free, 5)
self.assertEqual(user_updated.case_assigned_active, 7)
self.assertEqual(user_updated.case_assigned_closed, 9)
self.assertEqual(user_updated.case_assigned_sum, 21)
def test_order_for_user(self):
a = repr(
CaseFactory(
name="CaseA",
last_action=timezone.now() + timedelta(days=0),
last_send=timezone.now() + timedelta(days=+1),
))
b = repr(
CaseFactory(
name="CaseB",
last_action=timezone.now() + timedelta(days=+2),
last_send=timezone.now() + timedelta(days=-1),
))
c = repr(
CaseFactory(
name="CaseC",
last_action=timezone.now() + timedelta(days=-1),
last_send=timezone.now() + timedelta(days=+3),
))
user = UserFactory(is_staff=True)
self.assertQuerysetEqual(
Case.objects.order_for_user(user, True).all(), [c, a, b])
self.assertQuerysetEqual(
Case.objects.order_for_user(user, False).all(), [b, a, c])
user = UserFactory(is_staff=False)
self.assertQuerysetEqual(
Case.objects.order_for_user(user, True).all(), [b, a, c])
self.assertQuerysetEqual(
Case.objects.order_for_user(user, False).all(), [c, a, b])
def test_closed_to_assigned(self):
case = CaseFactory(pk=639, status=Case.STATUS.closed)
assign_perm('cases.can_send_to_client', UserFactory(is_staff=True), case)
msg = self.get_message('cc_message.eml')
MessageParser.receive_signal(sender=self.mailbox, message=msg)
case.refresh_from_db()
self.assertEqual(case.status, Case.STATUS.assigned)
def test_utf8_message(self):
if StrictVersion(django_mailbox.__version__) <= StrictVersion('4.5.3'):
self.skipTest("Django-mailbox is lower than required 4.5.3 " +
"to UTF-8 filename attachment")
case = CaseFactory(pk=639)
message = self.get_message('utf8_message.eml')
mail_process(sender=self.mailbox, message=message)
case.refresh_from_db()
self.assertEqual(case.status, Case.STATUS.free)
def test_get_by_email(self):
with self.assertRaises(Case.DoesNotExist):
Case.get_by_email('*****@*****.**')
Case.get_by_email('*****@*****.**')
obj = CaseFactory(pk=22)
obj2 = Case.get_by_email('*****@*****.**')
self.assertEqual(obj, obj2)
class ReceiveEmailTestCase(TestCase):
def setUp(self):
super(TestCase, self).setUp()
self.mailbox = Mailbox.objects.create(from_email='*****@*****.**')
@staticmethod
def _get_email_object(filename): # See coddingtonbear/django-mailbox#89
path = join(dirname(__file__), 'messages', filename)
msg_content = open(path, 'rb').read()
if six.PY3:
return email.message_from_bytes(msg_content)
else:
return email.message_from_string(msg_content)
def get_message(self, filename):
message = self._get_email_object(filename)
msg = self.mailbox._process_message(message)
msg.save()
return msg
def test_user_identification(self):
user = UserFactory(email='*****@*****.**')
message = self.get_message('cc_message.eml')
MessageParser.receive_signal(sender=self.mailbox, message=message)
self.assertEqual(user, message.letter_set.all()[0].created_by)
def test_cc_message(self):
case = CaseFactory(pk=639)
message = self.get_message('cc_message.eml')
MessageParser.receive_signal(sender=self.mailbox, message=message)
self.assertEqual(case, message.letter_set.all()[0].case)
class CaseCloseViewTestCase(TestCase):
def setUp(self):
self.user = UserFactory()
self.object = CaseFactory()
self.client.login(username=self.user.username, password='******')
def test_close_case(self):
assign_perm('cases.can_close_case', self.user, self.object)
resp = self.client.post(self.object.get_close_url(), {'notify': True})
self.assertEqual(
resp.context['target'].status,
Case.STATUS.closed)
def test_close_case_not_permitted(self):
resp = self.client.get(self.object.get_close_url())
self.assertEqual(resp.status_code, 403)
def case_with_assignees(self,
case_status,
staff_assignees=0,
non_staff_assignees=0):
"""
Build a case with a given set of assignees and set its status afterwards.
Will throw if provided params result in a volatile case, i.e. one that might change its status on the first `status_update` call. Such cases are not feasible for testing status restoration.
"""
perm_id = "cases.can_send_to_client"
case = CaseFactory()
for i in range(staff_assignees):
assign_perm(perm_id, UserFactory(is_staff=True), case)
for i in range(non_staff_assignees):
assign_perm(perm_id, UserFactory(is_staff=False), case)
case.status = case_status
case.save()
# Check if the status is valid, i.e. didn't change on the status update after making no changes.
case.status_update()
if case.status != case_status:
raise Exception(
f"Invalid case specified. Status changed to {case.status} after first update. Expected {case_status}."
)
class CaseQuerySetTestCase(TestCase):
def setUp(self):
self.user = UserFactory()
def test_for_assign_cant(self):
self.assertFalse(
Case.objects.for_user(
self.user).filter(pk=CaseFactory().pk).exists())
def test_for_user_cant(self):
self.assertFalse(
Case.objects.for_user(
self.user).filter(pk=CaseFactory().pk).exists())
def test_for_user_can_local_view(self):
assign_perm("cases.can_view", self.user)
self.assertTrue(
Case.objects.for_user(
self.user).filter(pk=CaseFactory().pk).exists())
def test_for_user_can_global_view(self):
case = CaseFactory()
assign_perm("cases.can_view", self.user, case)
self.assertTrue(
Case.objects.for_user(self.user).filter(pk=case.pk).exists())
class ReceiveEmailTestCase(TestCase):
def setUp(self):
self.url = reverse("letters:webhook")
self.authenticated_url = "{}?secret={}".format(self.url,
LETTER_RECEIVE_SECRET)
def test_required_authentication(self):
response = self.client.get(self.url)
self.assertEqual(response.status_code, 405)
def test_sample_request(self):
case = CaseFactory()
response = self.client.post(path=self.authenticated_url,
data=self._get_body(case))
self.assertEqual(response.json()["status"], "OK")
self.assertEqual(case.record_set.count(), 1)
letter = case.record_set.all()[0].content_object
self.assertEqual(letter.text,
"W dniach 3.07-17.08.2018 r. przebywam na urlopie.")
self.assertEqual(letter.attachment_set.all().count(), 1)
eml_content = letter.eml.read().decode("utf-8")
attachment_content = (
letter.attachment_set.all()[0].attachment.read().decode("utf-8"))
self.assertEqual(eml_content, "12345")
self.assertEqual(attachment_content, "my-content")
class CaseAdminTestCase(AdminTestCaseMixin, TestCase):
user_factory_cls = UserFactory
factory_cls = CaseFactory
model = Case
def setUp(self):
self.site = AdminSite()
super().setUp()
def assertIsValid(self, model_admin,
model): # See django/tests/modeladmin/tests.py#L602
admin_obj = model_admin(model, self.site)
if django.VERSION > (1, 9):
errors = admin_obj.check()
else:
errors = admin_obj.check(model)
expected = []
self.assertEqual(errors, expected)
def test_is_valid(self):
self.assertIsValid(CaseAdmin, Case)
def test_record_count(self):
case = CaseFactory()
LetterFactory.create_batch(size=25, case=case)
admin_obj = CaseAdmin(Case, AdminSite())
request = RequestFactory().get(
reverse_lazy("admin:cases_case_changelist"))
request.user = UserFactory(is_staff=True, is_superuser=True)
qs = admin_obj.get_queryset(request)
obj = qs.get(pk=case.pk)
self.assertTrue(hasattr(obj, "record_count"))
self.assertEqual(admin_obj.record_count(obj), 25)
def _prepare_cases(self, db_data):
for size, sent, created_on in db_data:
last_send = make_aware(datetime(2015, 1, 2)) if sent else None
for obj in CaseFactory.create_batch(size=size,
last_send=last_send):
obj.created_on = make_aware(created_on)
obj.save()
def setUp(self):
super(CaseCourtCreateViewTestCase, self).setUp()
self.user = UserFactory(username='******')
self.case = CaseFactory()
self.permission_object = self.case
self.url = reverse('judgements:create',
kwargs={'case_pk': str(self.case.pk)})
def setUp(self):
self.user = UserFactory(username="******", password="******")
self.user_with_permission = UserFactory()
self.permission_object = None # use global perms
self.object = CaseFactory()
self.url = reverse("cases:permission_add",
kwargs={"pk": self.object.pk})
def test_permission_filter(self):
obj = CaseFactory()
self.assertFalse(
self.get_permission_filter_qs(user=UserFactory(is_staff=True),
pk=obj.pk).exists())
user = UserFactory(is_staff=True)
assign_perm("cases.can_view", user, obj)
self.assertTrue(
self.get_permission_filter_qs(user=user, pk=obj.pk).exists())
def test_utf8_message(self):
if StrictVersion(django_mailbox.__version__) <= StrictVersion('4.5.3'):
self.skipTest("Django-mailbox is lower than required 4.5.3 " +
"to UTF-8 filename attachment")
case = CaseFactory(pk=639)
message = self.get_message('utf8_message.eml')
MessageParser.receive_signal(sender=self.mailbox, message=message)
case.refresh_from_db()
self.assertEqual(case.status, Case.STATUS.free)
def test_send_notification_to_management_in_free_cases(self):
free_case = CaseFactory()
management_user = UserFactory(notify_unassigned_letter=True)
EventFactory(case=free_case, time=timezone.now())
management.call_command('send_event_reminders', stdout=self.stdout)
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox.pop()
self.assertIn(management_user.email, email.recipients())
class CaseDetailViewTestCase(TestCase):
def setUp(self):
self.object = CaseFactory()
self.client.login(username=self.object.created_by.username, password='******')
def test_can_view(self):
self.client.get(self.object.get_absolute_url())
def test_display_letter(self):
obj = LetterFactory(case=self.object)
resp = self.client.get(self.object.get_absolute_url())
self.assertContains(resp, obj.name)
def test_hide_internal_letter(self):
obj = LetterFactory(case=self.object, status='staff')
obj2 = LetterFactory(case=self.object, status='done')
self.object.created_by.is_staff = False
self.object.created_by.save()
resp = self.client.get(self.object.get_absolute_url())
self.assertNotContains(resp, obj.name)
self.assertContains(resp, obj2.name)
class CaseDetailViewTestCase(TestCase):
def setUp(self):
self.object = CaseFactory()
self.client.login(username=self.object.created_by.username,
password="******")
def test_can_view(self):
self.client.get(self.object.get_absolute_url())
def test_display_letter(self):
obj = LetterFactory(case=self.object)
resp = self.client.get(self.object.get_absolute_url())
self.assertContains(resp, obj.name)
def test_hide_internal_letter(self):
obj = LetterFactory(case=self.object, status="staff")
obj2 = LetterFactory(case=self.object, status="done")
self.object.created_by.is_staff = False
self.object.created_by.save()
resp = self.client.get(self.object.get_absolute_url())
self.assertNotContains(resp, obj.name)
self.assertContains(resp, obj2.name)
def setUp(self):
self.user = UserFactory()
self.object = CaseFactory()
self.client.login(username=self.user.username, password='******')
def setUp(self):
self.object = CaseFactory()
self.client.login(username=self.object.created_by.username,
password="******")
def _prepare_cases(self, db_data):
for size, status, created_on in db_data:
for obj in CaseFactory.create_batch(size=size, status=status):
obj.created_on = make_aware(created_on)
obj.save()
def test_for_assign_no_duplicates_with_multiple_permissions(self):
assign_perm("cases.can_view", self.user)
assign_perm("cases.can_assign", self.user)
case = CaseFactory(created_by=self.user)
self.assertEqual(1, len(Case.objects.for_assign(self.user)))
def setUp(self):
self.subject_user = UserFactory()
self.user = UserFactory(username="******")
self.object = CaseFactory()
def test_for_user_can_local_view(self):
assign_perm("cases.can_view", self.user)
self.assertTrue(
Case.objects.for_user(
self.user).filter(pk=CaseFactory().pk).exists())
def test_for_user_cant(self):
self.assertFalse(
Case.objects.for_user(
self.user).filter(pk=CaseFactory().pk).exists())
def setUp(self):
self.object = CaseFactory()
self.client.login(username=self.object.created_by.username, password='******')
def setUp(self):
self.object = CaseFactory()
class CaseTestCase(TestCase):
def setUp(self):
self.object = CaseFactory()
def test_get_edit_url(self):
self.assertEqual(CaseFactory(pk=50).get_edit_url(), '/sprawy/sprawa-50/edytuj/')
def test_perm_check(self):
u1 = UserFactory()
assign_perm('cases.can_view', u1)
u2 = UserFactory()
assign_perm('cases.can_view', u2, self.object)
self.assertTrue(self.object.perm_check(u1, 'can_view'))
self.assertTrue(self.object.perm_check(u2, 'can_view'))
with self.assertRaises(PermissionDenied):
self.object.perm_check(UserFactory(), 'can_view')
def test_status_update_initial(self):
self.assertEqual(self.object.status, Case.STATUS.free)
def test_status_update_still_open(self):
assign_perm('cases.can_send_to_client', UserFactory(is_staff=False), self.object)
self.object.status_update()
self.assertEqual(self.object.status, Case.STATUS.free)
def test_status_update_assigned(self):
assign_perm('cases.can_send_to_client', UserFactory(is_staff=True), self.object)
self.object.status_update()
self.assertEqual(self.object.status, Case.STATUS.assigned)
def test_status_update_closed(self):
self.object.status = Case.STATUS.closed
self.object.status_update()
self.assertEqual(self.object.status, Case.STATUS.closed)
self.object.status_update(reopen=True)
self.assertEqual(self.object.status, Case.STATUS.free)
def test_update_counters_last_received_default(self):
self.object.update_counters()
self.assertEqual(self.object.last_received, None)
def _make_letter(self): # Hack for Travis
o = LetterFactory(case=self.object, created_by__is_staff=False)
return Letter.objects.get(pk=o.pk)
def test_update_counters_last_received_setup(self):
l = self._make_letter()
self.object.update_counters()
self.assertEqual(l.created_on, self.object.last_received)
def test_update_counters_last_received_update(self):
self._make_letter()
self.object.update_counters()
new = self._make_letter()
self.object.update_counters()
self.assertEqual(new.created_on, self.object.last_received)
def test_update_counters_hide_past_deadline(self):
event = EventFactory(time=timezone.now() - timedelta(days=5), deadline=True, case=self.object)
self.object.update_counters()
self.assertEqual(self.object.deadline, None)
def test_update_counters_show_future_deadline(self):
event = EventFactory(time=timezone.now() + timedelta(days=5), deadline=True, case=self.object)
self.object.update_counters()
self.assertEqual(self.object.deadline, event)
def setUp(self):
self.user = UserFactory(username="******")
self.case = CaseFactory()
def setUp(self):
self.user = UserFactory(username="******", password="******")
self.object = self.permission_object = CaseFactory()
self.url = self.object.get_close_url()
def test_get_edit_url(self):
self.assertEqual(
CaseFactory(pk=50).get_edit_url(), "/sprawy/sprawa-50/edytuj/")
class CaseTestCase(TestCase):
def setUp(self):
self.object = CaseFactory()
def test_get_edit_url(self):
self.assertEqual(CaseFactory(pk=50).get_edit_url(), '/sprawy/sprawa-50/edytuj/')
@override_settings(PORADNIA_EMAIL_INPUT='case-(?P<pk>\d+)@example.com')
def test_get_by_email(self):
with self.assertRaises(Case.DoesNotExist):
Case.get_by_email('*****@*****.**')
Case.get_by_email('*****@*****.**')
obj = CaseFactory(pk=22)
obj2 = Case.get_by_email('*****@*****.**')
self.assertEqual(obj, obj2)
def test_perm_check(self):
u1 = UserFactory()
assign_perm('cases.can_view', u1)
u2 = UserFactory()
assign_perm('cases.can_view', u2, self.object)
self.assertTrue(self.object.perm_check(u1, 'can_view'))
self.assertTrue(self.object.perm_check(u2, 'can_view'))
with self.assertRaises(PermissionDenied):
self.object.perm_check(UserFactory(), 'can_view')
def test_status_update_initial(self):
self.assertEqual(self.object.status, Case.STATUS.free)
def test_status_update_still_open(self):
assign_perm('cases.can_send_to_client', UserFactory(is_staff=False), self.object)
self.object.status_update()
self.assertEqual(self.object.status, Case.STATUS.free)
def test_status_update_assigned(self):
assign_perm('cases.can_send_to_client', UserFactory(is_staff=True), self.object)
self.object.status_update()
self.assertEqual(self.object.status, Case.STATUS.assigned)
def test_status_update_closed(self):
self.object.status = Case.STATUS.closed
self.object.status_update()
self.assertEqual(self.object.status, Case.STATUS.closed)
self.object.status_update(reopen=True)
self.assertEqual(self.object.status, Case.STATUS.free)
def test_update_counters_last_received_default(self):
self.object.update_counters()
self.assertEqual(self.object.last_received, None)
def _make_letter(self): # Hack for Travis
o = LetterFactory(case=self.object, created_by__is_staff=False)
return Letter.objects.get(pk=o.pk)
def test_update_counters_last_received_setup(self):
l = self._make_letter()
self.object.update_counters()
self.assertEqual(l.created_on, self.object.last_received)
def test_update_counters_last_received_update(self):
self._make_letter()
self.object.update_counters()
new = self._make_letter()
self.object.update_counters()
self.assertEqual(new.created_on, self.object.last_received)
def setUp(self):
self.user = UserFactory()
self.object = CaseFactory()
def test_has_assignees_other_case(self):
user = UserFactory(is_staff=True)
other_object = CaseFactory()
assign_perm("cases.can_send_to_client", user, other_object)
self.assertFalse(self.object.has_assignees())
def setUp(self):
self.user = UserFactory(username="******")
self.user_with_permission = UserFactory(is_staff=True)
self.object = CaseFactory()
self.url = reverse("cases:permission_grant",
kwargs={"pk": self.object.pk})
def test_with_record_count(self):
obj = CaseFactory()
LetterFactory.create_batch(size=25, case=obj)
self.assertEqual(
Case.objects.filter(
pk=obj.pk).with_record_count().get().record_count, 25)
def test_for_assign_can_view_created(self): # perm set by signal
self.assertTrue(
Case.objects.for_assign(self.user).filter(pk=CaseFactory(
client=self.user).pk).exists())
def test_with_case_count(self):
user = UserFactory()
CaseFactory.create_batch(size=25, client=user)
self.assertEqual(User.objects.with_case_count().get(pk=user.pk).case_count, 25)
self.assertEqual(User.objects.with_case_count().get(pk=UserFactory().pk).case_count, 0)
def test_with_perm(self):
CaseFactory.create_batch(size=25)
with self.assertNumQueries(2):
qs = Case.objects.with_perm().all()
for obj in qs:
list(obj.caseuserobjectpermission_set.all())
def _prepare_cases(self, db_data):
for created_on, letter_data in db_data:
for obj in CaseFactory.create_batch(size=1):
obj.letter_set = self._prepare_letters(letter_data, obj)
obj.created_on = make_aware(created_on)
obj.save()
def test_with_perm(self):
CaseFactory.create_batch(size=25)
with self.assertNumQueries(2):
qs = Case.objects.with_perm().all()
for obj in qs:
list(obj.caseuserobjectpermission_set.all())
def _prepare_cases(self, db_data):
for size, sent, created_on in db_data:
last_send = make_aware(datetime(2015, 1, 2)) if sent else None
for obj in CaseFactory.create_batch(size=size, last_send=last_send):
obj.created_on = make_aware(created_on)
obj.save()
