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}."
)
def test_form_fields(self):
su_user = UserFactory(is_staff=True, is_superuser=True)
self.assertCountEqual(
self.get_filter(user=su_user).form.fields.keys(),
[
"status",
"handled",
"id",
"client",
"name",
"has_project",
"permission",
"has_advice",
"o",
],
)
self.assertCountEqual(
self.get_filter(user=UserFactory(
is_staff=True)).form.fields.keys(),
[
"status",
"handled",
"id",
"client",
"name",
"has_project",
"permission",
"has_advice",
"o",
],
)
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 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_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_codename_visibility(self):
# Show for staff
self.assertIn('codename',
UserForm(instance=UserFactory(is_staff=True)).fields)
# Non-show for non-staff
self.assertNotIn('codename',
UserForm(instance=UserFactory(is_staff=False)).fields)
# Non show for new object
self.assertNotIn('codename', UserForm().fields)
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 make_privileged_user(self):
"""Returns a user with permissions granted"""
permissions = self.get_permissions()
if "superuser" in permissions:
permissions.pop(permissions.index("superuser"))
user = UserFactory(username="******", is_superuser=True)
else:
user = UserFactory(username="******")
for perm in permissions:
assign_perm(perm, user)
return user
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 _prepare_users(self, db_data):
admin = None
for created_on in db_data:
if admin is None:
obj = UserFactory(is_superuser=True)
admin = obj
else:
obj = UserFactory()
obj.created_on = make_aware(created_on) if created_on is not None else None
obj.save()
return admin
def test_for_user_manager(self):
UserFactory()
u1 = UserFactory()
u2 = UserFactory(is_staff=True)
u3 = UserFactory(is_staff=True, is_superuser=True)
self.assertEqual(User.objects.for_user(u1).registered().count(),
3) # self + 2 staff
self.assertEqual(User.objects.for_user(u2).registered().count(),
2) # 2 staff with self
self.assertEqual(User.objects.for_user(u3).registered().count(),
4) # all
def test_notify_user_with_notify_unassigned_letter(self):
management_user = UserFactory(notify_unassigned_letter=True)
self.user = UserFactory(is_staff=True)
assign_perm("can_add_record", self.user, self.case)
self.client.login(username=self.user.username, password="******")
data = self.post_data.copy()
data["project"] = "True"
self.client.post(self.url, data=data)
self.assertMailSend(to=management_user.email)
def test_form_fields(self):
su_user = UserFactory(is_staff=True, is_superuser=True)
self.assertItemsEqual(
self.get_filter(user=su_user).form.fields.keys(), [
'status', 'handled', 'id', 'client', 'name', 'has_project',
'permission', 'o'
])
self.assertItemsEqual(
self.get_filter(user=UserFactory(
is_staff=True)).form.fields.keys(), [
'status', 'handled', 'id', 'client', 'name', 'has_project',
'permission', 'o'
])
def test_not_notify_management_if_has_lawyer(self):
management_user = UserFactory(notify_unassigned_letter=True)
self.user = UserFactory(is_staff=False)
assign_perm("can_add_record", self.user, self.case)
assign_perm("can_send_to_client", UserFactory(is_staff=True),
self.case)
self.client.login(username=self.user.username, password="******")
data = self.post_data.copy()
self.client.post(self.url, data=data)
self.assertMailSend(to=management_user.email, expected_count=0)
def test_not_notify_management_if_has_lawyer(self):
management_user = UserFactory(notify_unassigned_letter=True)
self.user = UserFactory(is_staff=False)
assign_perm("can_add_record", self.user, self.case)
assign_perm("can_send_to_client", UserFactory(is_staff=True), self.case)
self.client.login(username=self.user.username, password="******")
data = self.post_data.copy()
self.client.post(self.url, data=data)
emails = [x.to[0] for x in mail.outbox]
self.assertNotIn(management_user.email, emails)
def test_limit_choices_of_users(self):
obj = UserFactory()
managed_user = UserFactory()
form = TranslatedManageObjectPermissionForm(
data={"permissions": ["change_user"], "users": [managed_user.pk]},
actor=managed_user,
obj=obj,
)
self.assertTrue(form.is_valid())
form = TranslatedManageObjectPermissionForm(
data={"permissions": ["change_user"], "users": [UserFactory().pk]},
actor=managed_user,
obj=obj,
)
self.assertFalse(form.is_valid())
def test_notify_user_with_notify_unassigned_letter(self):
management_user = UserFactory(notify_unassigned_letter=True)
self.user = UserFactory(is_staff=True)
assign_perm('can_add_record', self.user, self.case)
self.client.login(username=self.user.username, password='******')
data = self.post_data.copy()
data["project"] = "True"
self.client.post(self.url, data=data)
emails = [x.to[0] for x in mail.outbox]
self.assertIn(management_user.email, emails)
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 test_basic(self):
db_data = [
(datetime(2015, 1, 2), self.non_staff_user),
(datetime(2015, 1, 2), self.staff_user),
(datetime(2015, 2, 3), self.non_staff_user),
]
user = UserFactory(is_superuser=True)
self.client.login(username=user.username, password="******")
self._prepare_letters(db_data)
result = self.client.get(self.url).json()
expected = [
{
"date": "2015-01",
"staff": 1,
"client": 1
},
{
"date": "2015-02",
"staff": 0,
"client": 1
},
]
self.assertEqual(result, expected)
def test_no_cases(self):
user = UserFactory(is_superuser=True)
self.client.login(username=user.username, password="******")
result = self.client.get(self.url).json()
expected = []
self.assertEqual(result, expected)
def test_permission_access_and_filter(self):
self.client.login(username=UserFactory().username, password="******")
resp = self.client.get(self.url)
self.assertEqual(resp.status_code, 302)
self.client.login(username=UserFactory(is_staff=True).username, password="******")
resp = self.client.get(self.url)
self.assertContains(resp, self.staff_list[0].username)
self.assertNotContains(resp, self.user_list[0].username)
user = UserFactory(is_staff=True)
assign_perm("users.can_view_other", user)
self.client.login(username=user.username, password="******")
resp = self.client.get(self.url)
self.assertContains(resp, self.object_list[0].username)
self.assertContains(resp, self.object_list[0].username)
def setUp(self):
super(CaseCourtDeleteViewTestCase, self).setUp()
self.user = UserFactory(username='******')
self.court_case = CourtCaseFactory()
self.permission_object = self.court_case.case
self.url = reverse('judgements:delete',
kwargs={'pk': self.court_case.pk})
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_gap_by_month(self):
db_data = [
(
datetime(2015, 1, 2),
[(datetime(2015, 4, 2), self.staff_user, Letter.STATUS.done)],
),
(
datetime(2015, 3, 3),
[(datetime(2015, 3, 4), self.staff_user, Letter.STATUS.done)],
),
]
user = UserFactory(is_superuser=True)
self.client.login(username=user.username, password="******")
self._prepare_cases(db_data)
result = self.client.get(self.url).json()
expected = [
{
"date": "2015-01",
"reaction_time": 89
},
{
"date": "2015-02",
"reaction_time": 0
},
{
"date": "2015-03",
"reaction_time": 1
},
]
self.assertEqual(result, expected)
def setUp(self):
self.object = UserFactory(is_staff=False)
self.url = self.object.get_absolute_url()
self.client_filter_url = reverse('cases:list') + '?client=' + str(
self.object.pk)
self.permission_filter_url = reverse(
'cases:list') + '?permission=' + str(self.object.pk)
def setUp(self):
self.user = UserFactory(username=settings.JUDGEMENT_BOT_USERNAME)
self.stdout = StringIO()
self.stderr = StringIO()
self.manager = Manager(bot=self.user,
stdout=self.stdout,
stderr=self.stderr)
def test_gap_by_month(self):
db_data = [
(1, Case.STATUS.free, datetime(2015, 1, 2)),
(2, Case.STATUS.assigned, datetime(2015, 1, 2)),
(3, Case.STATUS.closed, datetime(2015, 1, 2)),
(2, Case.STATUS.free, datetime(2015, 3, 2)),
(1, Case.STATUS.assigned, datetime(2015, 3, 2)),
]
user = UserFactory(is_superuser=True)
self.client.login(username=user.username, password="******")
self._prepare_cases(db_data)
result = self.client.get(self.url).json()
expected = [
{
"date": "2015-01",
"open": 1,
"assigned": 2,
"closed": 3
},
{
"date": "2015-02",
"open": 0,
"assigned": 0,
"closed": 0
},
{
"date": "2015-03",
"open": 2,
"assigned": 1,
"closed": 0
},
]
self.assertEqual(result, expected)
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 test_user_permission_after_create(self):
user = UserFactory()
response = self.client.post(path=self.authenticated_url,
data=self._get_body(from_=user.email))
self.assertEqual(response.json()["status"], "OK")
case = Case.objects.get()
self.assertTrue(
case.get_users_with_perms().filter(pk=case.created_by.pk).exists())
def test_status_update_reopen_with_assignee(self):
assign_perm("cases.can_send_to_client", UserFactory(is_staff=True),
self.object)
self.object.status = Case.STATUS.closed
self.object.status_update(reopen=False)
self.assertEqual(self.object.status, Case.STATUS.closed)
self.object.status_update(reopen=True)
self.assertEqual(self.object.status, Case.STATUS.assigned)
