def test_create_and_assign_agilisys_organisation_idempotent(self):
make_recipe("call_centre.operator",
user=make_user(email="*****@*****.**"))
make_recipe("call_centre.operator",
user=make_user(email="*****@*****.**"))
out = StringIO()
call_command("create_and_assign_agilisys_organisation", stdout=out)
call_command("create_and_assign_agilisys_organisation", stdout=out)
self.assertIn("Could not find Agilisys operators to update",
out.getvalue())
def setUp(self):
super(CaseworkerAdminViewTestCase, self).setUp()
def make_op(username, is_manager=False, is_cla_superuser=False):
return make_recipe(
"call_centre.operator",
user__username=username,
is_manager=is_manager,
is_cla_superuser=is_cla_superuser,
)
def make_cw(**kwargs):
return make_recipe("call_centre.caseworker", **kwargs)
self.django_admin = make_user(is_staff=True, is_superuser=True)
self.operators = {
"op_manager1": make_op("op_manager1", is_manager=True),
"op_superuser1": make_op("op_superuser1", is_manager=True, is_cla_superuser=True),
"cw_1": make_cw(),
}
# setting password == username
for user in [op.user for op in self.operators.values()] + [self.django_admin]:
user.set_password(user.username)
user.save()
class Add72workingHoursToContextCommandTestCase(CallCentreFixedOperatingHours,
TestCase):
def setUp(self):
super(Add72workingHoursToContextCommandTestCase, self).setUp()
self.instance = Command()
def create_callback(self, requires_action_at):
case = make_recipe("legalaid.case")
user = make_user()
make_recipe("call_centre.operator", user=user)
event = event_registry.get_event("call_me_back")()
event.get_log_code(case=case)
log = event.process(
case,
created_by=user,
notes="",
context={
"requires_action_at": requires_action_at,
"sla_15": get_sla_time(requires_action_at, 15),
"sla_30": get_sla_time(requires_action_at, 30),
"sla_120": get_sla_time(requires_action_at, 120),
"sla_480": get_sla_time(requires_action_at, 480),
},
)
case.set_requires_action_at(requires_action_at)
return log
def test_set_requires_action_by(self):
"""
Tests that:
* if the code has the key `set_requires_action_by`,
after process, case.requires_action_by will be set to
that value
* if the code doesn't have the key `set_requires_action_by`,
after process, case.requires_action_by won't change
"""
if not self.EVENT_KEY:
return
event = event_registry.get_event(self.EVENT_KEY)()
for code, code_data in event.codes.items():
self.dummy_case.requires_action_by = None
self.dummy_case.save()
user = make_user()
event.process(**{"case": self.dummy_case, "code": code, "notes": "this is a note", "created_by": user})
case = Case.objects.get(pk=self.dummy_case.pk)
if "set_requires_action_by" in code_data:
set_requires_action_by = code_data["set_requires_action_by"]
if callable(set_requires_action_by):
set_requires_action_by = set_requires_action_by(self.dummy_case)
self.assertEqual(case.requires_action_by, set_requires_action_by)
else:
self.assertEqual(case.requires_action_by, None)
def test_save_in_office_hours(self, timezone_mock):
_mock_datetime_now_with(datetime.datetime(2014, 1, 2, 9, 1, 0),
timezone_mock)
case = make_recipe('legalaid.case')
category = case.eligibility_check.category
case.matter_type1 = make_recipe('legalaid.matter_type1',
category=category)
case.matter_type2 = make_recipe('legalaid.matter_type2',
category=category)
case.save()
user = make_user()
provider = make_recipe('cla_provider.provider', active=True)
make_recipe('cla_provider.provider_allocation',
weighted_distribution=0.5,
provider=provider,
category=category)
helper = ProviderAllocationHelper()
form = ProviderAllocationForm(case=case, data={
'provider': helper.get_suggested_provider(category).pk},
providers=helper.get_qualifying_providers(
category))
self.assertTrue(form.is_valid())
self.assertEqual(Log.objects.count(), 0)
form.save(user)
self.assertEqual(case.provider, provider)
self.assertEqual(Log.objects.count(), 1)
def test_save_in_office_hours(self, timezone_mock):
_mock_datetime_now_with(datetime.datetime(2014, 1, 2, 9, 1, 0),
timezone_mock)
case = make_recipe("legalaid.case")
category = case.eligibility_check.category
case.matter_type1 = make_recipe("legalaid.matter_type1",
category=category)
case.matter_type2 = make_recipe("legalaid.matter_type2",
category=category)
case.save()
user = make_user()
provider = make_recipe("cla_provider.provider", active=True)
make_recipe("cla_provider.provider_allocation",
weighted_distribution=0.5,
provider=provider,
category=category)
helper = ProviderAllocationHelper()
form = ProviderAllocationForm(
case=case,
data={"provider": helper.get_suggested_provider(category).pk},
providers=helper.get_qualifying_providers(category),
)
self.assertTrue(form.is_valid())
self.assertEqual(Log.objects.count(), 0)
form.save(user)
self.assertEqual(case.provider, provider)
self.assertEqual(Log.objects.count(), 1)
def setUp(self):
super(ConsecutiveOutcomeCodesTestCase, self).setUp()
self.dummy_case = make_recipe("legalaid.case")
self.dummy_user = make_user()
self.log_attributes = dict(
case=self.dummy_case, code="FOO", type=LOG_TYPES.OUTCOME, level=LOG_LEVELS.HIGH, created_by=self.dummy_user
)
def setUp(self):
super(CaseworkerAdminViewTestCase, self).setUp()
def make_op(username, is_manager=False, is_cla_superuser=False):
return make_recipe(
"call_centre.operator",
user__username=username,
is_manager=is_manager,
is_cla_superuser=is_cla_superuser,
)
def make_cw(**kwargs):
return make_recipe("call_centre.caseworker", **kwargs)
self.django_admin = make_user(is_staff=True, is_superuser=True)
self.operators = {
"op_manager1": make_op("op_manager1", is_manager=True),
"op_superuser1": make_op("op_superuser1", is_manager=True, is_cla_superuser=True),
"cw_1": make_cw(),
}
# setting password == username
for user in [op.user for op in self.operators.values()] + [self.django_admin]:
user.set_password(user.username)
user.save()
def setUp(self):
super(OperatorAdminViewTestCase, self).setUp()
def make_op(username, is_manager=False, is_cla_superuser=False, **kwargs):
return make_recipe(
"call_centre.operator",
user__username=username,
is_manager=is_manager,
is_cla_superuser=is_cla_superuser,
**kwargs
)
self.django_admin = make_user(is_staff=True, is_superuser=True)
self.foo_organisation = make_recipe("call_centre.organisation", name="Foo org")
self.bar_organisation = make_recipe("call_centre.organisation", name="Bar org")
self.operators = {
"op": make_op("op"),
"foo_org_op": make_op("foo_org_op", organisation=self.foo_organisation),
"foo_org_manager": make_op("foo_org_manager", is_manager=True, organisation=self.foo_organisation),
"bar_org_op": make_op("bar_org_op", organisation=self.bar_organisation),
"bar_org_manager": make_op("bar_org_manager", is_manager=True, organisation=self.bar_organisation),
"op_manager1": make_op("op_manager1", is_manager=True),
"op_manager2": make_op("op_manager2", is_manager=True),
"op_superuser1": make_op("op_superuser1", is_manager=True, is_cla_superuser=True),
"op_superuser2": make_op("op_superuser2", is_manager=True, is_cla_superuser=True),
}
# setting password == username
for user in [op.user for op in self.operators.values()] + [self.django_admin]:
user.set_password(user.username)
user.save()
def test_stops_timer(self):
if not self.EVENT_KEY:
return
event = event_registry.get_event(self.EVENT_KEY)()
for code, code_data in event.codes.items():
user = make_user()
timer = make_recipe('timer.Timer', created_by=user)
res = event.process(**{
'case': self.dummy_case,
'code': code,
'notes': 'this is a note',
'created_by': user
})
timer = Timer.objects.get(pk=timer.pk)
if code_data['stops_timer']:
self.assertTrue(timer.is_stopped())
self.assertEqual(res.timer, timer)
else:
self.assertFalse(timer.is_stopped())
self.assertEqual(res.timer, timer)
def setUp(self):
self.personal_details = make_recipe("legalaid.personal_details")
save_diversity_data(self.personal_details.pk, {"test": "test"})
self.task = OBIEEExportTask()
self.task._create_export = mock.MagicMock()
self.task.send_to_s3 = mock.MagicMock()
self.user = make_user()
def test_start(self):
self.assertEqual(Timer.objects.count(), 0)
user = make_user()
timer = Timer.start(user)
self.assertEqual(Timer.objects.count(), 1)
self.assertEqual(Timer.objects.first(), timer)
def test_start(self):
self.assertEqual(Timer.objects.count(), 0)
user = make_user()
timer = Timer.start(user)
self.assertEqual(Timer.objects.count(), 1)
self.assertEqual(Timer.objects.first(), timer)
def test_creates_timer(self):
self.assertEqual(Timer.objects.count(), 0)
user = make_user()
timer = create_timer(user)
self.assertEqual(Timer.objects.count(), 1)
timer = Timer.objects.first()
self.assertEqual(timer.created_by, user)
def test_creates_timer(self):
self.assertEqual(Timer.objects.count(), 0)
user = make_user()
timer = create_timer(user)
self.assertEqual(Timer.objects.count(), 1)
timer = Timer.objects.first()
self.assertEqual(timer.created_by, user)
def setUp(self):
super(ConsecutiveOutcomeCodesTestCase, self).setUp()
self.dummy_case = make_recipe("legalaid.case")
self.dummy_user = make_user()
self.log_attributes = dict(case=self.dummy_case,
code="FOO",
type=LOG_TYPES.OUTCOME,
level=LOG_LEVELS.HIGH,
created_by=self.dummy_user)
def test_save_out_office_hours_saturday(self, timezone_mock,
models_timezone_mock):
_mock_datetime_now_with(datetime.datetime(2014, 11, 1, 10, 30, 0),
timezone_mock, models_timezone_mock)
case = make_recipe("legalaid.case")
category = case.eligibility_check.category
case.matter_type1 = make_recipe("legalaid.matter_type1",
category=category)
case.matter_type2 = make_recipe("legalaid.matter_type2",
category=category)
case.save()
user = make_user()
provider = make_recipe("cla_provider.provider", active=True)
in_hours_provider = make_recipe("cla_provider.provider", active=True)
make_recipe(
"cla_provider.outofhoursrota",
provider=provider,
start_date=datetime.datetime(
2013, 12, 30).replace(tzinfo=timezone.get_current_timezone()),
end_date=datetime.datetime(
2014, 12, 2).replace(tzinfo=timezone.get_current_timezone()),
category=category,
)
make_recipe("cla_provider.provider_allocation",
weighted_distribution=1,
provider=in_hours_provider,
category=category)
make_recipe("cla_provider.provider_allocation",
weighted_distribution=0,
provider=provider,
category=category)
with mock.patch.object(
ProviderAllocationHelper,
"_get_random_provider",
return_value=in_hours_provider) as mocked_get_random_provider:
helper = ProviderAllocationHelper()
form = ProviderAllocationForm(
case=case,
data={"provider": helper.get_suggested_provider(category).pk},
providers=helper.get_qualifying_providers(category),
)
self.assertEqual(mocked_get_random_provider.call_count, 0)
self.assertTrue(form.is_valid())
self.assertEqual(Log.objects.count(), 0)
form.save(user)
self.assertEqual(case.provider, provider)
self.assertEqual(Log.objects.count(), 1)
def test_get_by_user_fails_with_multiple_timers(self):
try:
user = make_user()
make_recipe("timer.Timer", stopped=None, created_by=user, _quantity=2)
Timer.running_objects.get_by_user(user)
except (MultipleObjectsReturned, IntegrityError):
pass
else:
self.assertTrue(False, "It should raise MultipleObjectsReturned or IntegrityError")
def test_get_by_user_returns_timer(self):
user = make_user()
timer = make_recipe(
'timer.Timer', stopped=None, created_by=user
)
self.assertEqual(
Timer.running_objects.get_by_user(user),
timer
)
def test_returns_created(self):
self.assertEqual(Timer.objects.count(), 0)
user = make_user()
timer, created = get_or_create_timer(user)
self.assertEqual(Timer.objects.count(), 1)
timer = Timer.objects.first()
self.assertEqual(timer.created_by, user)
self.assertEqual(created, True)
def test_returns_created(self):
self.assertEqual(Timer.objects.count(), 0)
user = make_user()
timer, created = get_or_create_timer(user)
self.assertEqual(Timer.objects.count(), 1)
timer = Timer.objects.first()
self.assertEqual(timer.created_by, user)
self.assertEqual(created, True)
def test_billable_time(self):
case = make_recipe("legalaid.Case")
user = make_user()
timer = make_recipe("timer.Timer", linked_case=case, created_by=user)
make_recipe("cla_eventlog.Log", timer=timer, case=case)
timer.stop()
self.assertEqual(case.billable_time, 0)
def test_get_by_user_fails_when_no_timer(self):
user = make_user()
make_recipe(
'timer.Timer', stopped=timezone.now(), created_by=user
)
self.assertRaises(
IndexError,
Timer.running_objects.get_by_user,
user
)
def test_get_by_user_fails_with_multiple_timers(self):
user = make_user()
make_recipe(
'timer.Timer', stopped=None, created_by=user,
_quantity=2
)
self.assertRaises(
MultipleObjectsReturned,
Timer.running_objects.get_by_user, user
)
def create_and_login_user(self, is_staff=True):
random_username = get_random_string(length=10)
user = make_user(is_staff=is_staff,
is_active=True,
username=random_username)
user.set_password('password')
user.save()
logged_in = self.client.login(username=random_username,
password='******')
self.assertTrue(logged_in)
def _test_save_with_outcome(self, internal):
if internal:
outcome_code = 'REF-INT'
system_outcome_code = 'REF-INT_CREATED'
else:
outcome_code = 'REF-EXT'
system_outcome_code = 'REF-EXT_CREATED'
case_log_set_size = self.case.log_set.count()
self.assertEqual(Case.objects.count(), 1)
form = SplitCaseForm(
case=self.case, request=self.request,
data=self.get_default_data(
category=self.cat2_data.category.code,
matter_type1=self.cat2_data.matter_type1.code,
matter_type2=self.cat2_data.matter_type2.code,
notes='Notes',
internal=internal
)
)
self.assertTrue(form.is_valid())
user = make_user()
new_case = form.save(user)
self.assertEqual(Case.objects.count(), 2)
# xxx_CREATED outcome codes for original case
self.assertEqual(self.case.log_set.count(), case_log_set_size+1)
original_case_log = self.case.log_set.last()
self.assertEqual(original_case_log.code, system_outcome_code)
self.assertEqual(
original_case_log.notes,
'Split case created and referred %s' % (
'internally' if internal else 'externally'
)
)
# 2 outcome codes for new case
log_entries = new_case.log_set.order_by('created')
self.assertEqual(len(log_entries), 2)
# 1st CASE_CREATED
log_created = log_entries[0]
self.assertEqual(log_created.code, 'CASE_CREATED')
self.assertEqual(log_created.notes, 'Case created by Specialist')
self.assertEqual(log_created.created_by, user)
# 2nd REF-INT or REF-EXT
log_ref = log_entries[1]
self.assertEqual(log_ref.code, outcome_code)
self.assertEqual(log_ref.notes, 'Notes')
self.assertEqual(log_ref.created_by, user)
def _test_save_with_outcome(self, internal):
if internal:
outcome_code = "REF-INT"
system_outcome_code = "REF-INT_CREATED"
else:
outcome_code = "REF-EXT"
system_outcome_code = "REF-EXT_CREATED"
case_log_set_size = self.case.log_set.count()
self.assertEqual(Case.objects.count(), 1)
form = SplitCaseForm(
case=self.case,
request=self.request,
data=self.get_default_data(
category=self.cat2_data.category.code,
matter_type1=self.cat2_data.matter_type1.code,
matter_type2=self.cat2_data.matter_type2.code,
notes="Notes",
internal=internal,
),
)
self.assertTrue(form.is_valid())
user = make_user()
new_case = form.save(user)
self.assertEqual(Case.objects.count(), 2)
# xxx_CREATED outcome codes for original case
self.assertEqual(self.case.log_set.count(), case_log_set_size + 1)
original_case_log = self.case.log_set.last()
self.assertEqual(original_case_log.code, system_outcome_code)
self.assertEqual(
original_case_log.notes,
"Split case created and referred %s" %
("internally" if internal else "externally"),
)
# 2 outcome codes for new case
log_entries = new_case.log_set.order_by("created")
self.assertEqual(len(log_entries), 2)
# 1st CASE_CREATED
log_created = log_entries[0]
self.assertEqual(log_created.code, "CASE_CREATED")
self.assertEqual(log_created.notes, "Case created by Specialist")
self.assertEqual(log_created.created_by, user)
# 2nd REF-INT or REF-EXT
log_ref = log_entries[1]
self.assertEqual(log_ref.code, outcome_code)
self.assertEqual(log_ref.notes, "Notes")
self.assertEqual(log_ref.created_by, user)
def test_save_out_office_hours_saturday(self, timezone_mock, models_timezone_mock):
_mock_datetime_now_with(datetime.datetime(2014, 11, 1, 10, 30, 0),
timezone_mock, models_timezone_mock)
case = make_recipe('legalaid.case')
category = case.eligibility_check.category
case.matter_type1 = make_recipe('legalaid.matter_type1',
category=category)
case.matter_type2 = make_recipe('legalaid.matter_type2',
category=category)
case.save()
user = make_user()
provider = make_recipe('cla_provider.provider', active=True)
in_hours_provider = make_recipe('cla_provider.provider', active=True)
make_recipe('cla_provider.outofhoursrota',
provider=provider,
start_date=datetime.datetime(2013, 12, 30).replace(
tzinfo=timezone.get_current_timezone()),
end_date=datetime.datetime(2014, 12, 2).replace(
tzinfo=timezone.get_current_timezone()),
category=category
)
make_recipe('cla_provider.provider_allocation',
weighted_distribution=1,
provider=in_hours_provider,
category=category)
make_recipe('cla_provider.provider_allocation',
weighted_distribution=0,
provider=provider,
category=category)
with mock.patch.object(ProviderAllocationHelper, '_get_random_provider', return_value=in_hours_provider) as mocked_get_random_provider:
helper = ProviderAllocationHelper()
form = ProviderAllocationForm(case=case, data={
'provider': helper.get_suggested_provider(category).pk},
providers=helper.get_qualifying_providers(
category))
self.assertEqual(mocked_get_random_provider.call_count, 0)
self.assertTrue(form.is_valid())
self.assertEqual(Log.objects.count(), 0)
form.save(user)
self.assertEqual(case.provider, provider)
self.assertEqual(Log.objects.count(), 1)
def test_rollback_on_unexpected_exception_during_save(
self, mocked_event_registry):
"""
In case of unexpected Exception, we don't want to have any rubbish
objects in the db
"""
mocked_event_registry.get_event.side_effect = Exception()
case = get_full_case(self.cat2_data.matter_type1,
self.cat2_data.matter_type2,
provider=self.provider)
expected_counts = {}
for Model in [
AdaptationDetails,
Case,
CaseKnowledgebaseAssignment,
Deductions,
EligibilityCheck,
Income,
Person,
PersonalDetails,
Property,
Savings,
ThirdPartyDetails,
DiagnosisTraversal,
]:
expected_counts[Model] = Model.objects.count()
form = SplitCaseForm(
case=case,
request=self.request,
data=self.get_default_data(
category=self.cat2_data.category.code,
matter_type1=self.cat2_data.matter_type1.code,
matter_type2=self.cat2_data.matter_type2.code,
internal=False,
),
)
self.assertTrue(form.is_valid())
self.assertRaises(Exception, form.save, make_user())
self.assertTrue(expected_counts)
for Model, expected_count in expected_counts.items():
self.assertEqual(
Model.objects.count(),
expected_count,
"%s count Expected to be %s but it's %s instead" %
(Model, expected_count, Model.objects.count()),
)
def test_get_by_user_fails_with_multiple_timers(self):
try:
user = make_user()
make_recipe("timer.Timer",
stopped=None,
created_by=user,
_quantity=2)
Timer.running_objects.get_by_user(user)
except (MultipleObjectsReturned, IntegrityError):
pass
else:
self.assertTrue(
False,
"It should raise MultipleObjectsReturned or IntegrityError")
def test_save_out_office_hours(self, timezone_mock, models_timezone_mock):
_mock_datetime_now_with(datetime.datetime(2014, 1, 2, 8, 59, 0),
timezone_mock, models_timezone_mock)
case = make_recipe("legalaid.case")
category = case.eligibility_check.category
case.matter_type1 = make_recipe("legalaid.matter_type1",
category=category)
case.matter_type2 = make_recipe("legalaid.matter_type2",
category=category)
case.save()
user = make_user()
provider = make_recipe("cla_provider.provider", active=True)
make_recipe(
"cla_provider.outofhoursrota",
provider=provider,
start_date=datetime.datetime(
2013, 12, 30).replace(tzinfo=timezone.get_current_timezone()),
end_date=datetime.datetime(
2014, 1, 2, 9,
0).replace(tzinfo=timezone.get_current_timezone()),
category=category,
)
make_recipe("cla_provider.provider_allocation",
weighted_distribution=0.5,
provider=provider,
category=category)
# TODO - create a ProviderAllocation for this provider with the
# same category as the case and a positive weighted_distribution
helper = ProviderAllocationHelper()
form = ProviderAllocationForm(
case=case,
data={"provider": helper.get_suggested_provider(category).pk},
providers=helper.get_qualifying_providers(category),
)
self.assertTrue(form.is_valid())
self.assertEqual(Log.objects.count(), 0)
form.save(user)
self.assertEqual(case.provider, provider)
self.assertEqual(Log.objects.count(), 1)
def test_rollback_on_unexpected_exception_during_save(self, mocked_event_registry):
"""
In case of unexpected Exception, we don't want to have any rubbish
objects in the db
"""
mocked_event_registry.get_event.side_effect = Exception()
case = get_full_case(self.cat2_data.matter_type1, self.cat2_data.matter_type2, provider=self.provider)
expected_counts = {}
for Model in [
AdaptationDetails,
Case,
CaseKnowledgebaseAssignment,
Deductions,
EligibilityCheck,
Income,
Person,
PersonalDetails,
Property,
Savings,
ThirdPartyDetails,
DiagnosisTraversal,
]:
expected_counts[Model] = Model.objects.count()
form = SplitCaseForm(
case=case,
request=self.request,
data=self.get_default_data(
category=self.cat2_data.category.code,
matter_type1=self.cat2_data.matter_type1.code,
matter_type2=self.cat2_data.matter_type2.code,
internal=False,
),
)
self.assertTrue(form.is_valid())
self.assertRaises(Exception, form.save, make_user())
self.assertTrue(expected_counts)
for Model, expected_count in expected_counts.items():
self.assertEqual(
Model.objects.count(),
expected_count,
"%s count Expected to be %s but it's %s instead" % (Model, expected_count, Model.objects.count()),
)
def test_save_out_office_hours(self, timezone_mock, models_timezone_mock):
_mock_datetime_now_with(datetime.datetime(2014, 1, 2, 8, 59, 0),
timezone_mock, models_timezone_mock)
case = make_recipe('legalaid.case')
category = case.eligibility_check.category
case.matter_type1 = make_recipe('legalaid.matter_type1',
category=category)
case.matter_type2 = make_recipe('legalaid.matter_type2',
category=category)
case.save()
user = make_user()
provider = make_recipe('cla_provider.provider', active=True)
make_recipe('cla_provider.outofhoursrota',
provider=provider,
start_date=datetime.datetime(2013, 12, 30).replace(
tzinfo=timezone.get_current_timezone()),
end_date=datetime.datetime(2014, 1, 2).replace(
tzinfo=timezone.get_current_timezone()),
category=category
)
make_recipe('cla_provider.provider_allocation',
weighted_distribution=0.5,
provider=provider,
category=category)
# TODO - create a ProviderAllocation for this provider with the
# same category as the case and a positive weighted_distribution
helper = ProviderAllocationHelper()
form = ProviderAllocationForm(case=case, data={
'provider': helper.get_suggested_provider(category).pk},
providers=helper.get_qualifying_providers(
category))
self.assertTrue(form.is_valid())
self.assertEqual(Log.objects.count(), 0)
form.save(user)
self.assertEqual(case.provider, provider)
self.assertEqual(Log.objects.count(), 1)
def test_command(self):
group = Group.objects.get(name="CLA Superusers")
cla_superuser = make_user()
group.user_set.add(cla_superuser)
content_type = ContentType.objects.get(app_label="knowledgebase",
model="articlecategory")
perms = [
"knowledgebase.{}".format(perm.codename)
for perm in Permission.objects.filter(content_type=content_type)
]
self.assertFalse(cla_superuser.has_perms(perms))
call_command("grant_cla_superusers_article_categories_permissions")
# Reload the user object
user = User.objects.get(pk=cla_superuser.pk)
self.assertTrue(user.has_perms(perms))
def test_stops_timer(self):
if not self.EVENT_KEY:
return
event = event_registry.get_event(self.EVENT_KEY)()
for code, code_data in event.codes.items():
user = make_user()
timer = make_recipe("timer.Timer", created_by=user)
res = event.process(
**{"case": self.dummy_case, "code": code, "notes": "this is a note", "created_by": user}
)
timer = Timer.objects.get(pk=timer.pk)
if code_data["stops_timer"]:
self.assertTrue(timer.is_stopped())
self.assertEqual(res.timer, timer)
else:
self.assertFalse(timer.is_stopped())
self.assertEqual(res.timer, timer)
def test_call_started_sla(self):
with patch_field(Log, "created", _make_datetime(2015, 1, 2, 9, 0, 0)):
case = make_recipe("legalaid.case")
user = make_user()
make_recipe("call_centre.operator", user=user)
event = event_registry.get_event("call_me_back")()
_dt = _make_datetime(2015, 1, 2, 9, 1, 0)
with patch_field(Log, "created", _make_datetime(2015, 1, 2, 9, 1, 0)):
event.get_log_code(case=case)
event.process(
case,
created_by=user,
notes="",
context={
"requires_action_at": _dt,
"sla_15": get_sla_time(_dt, 15),
"sla_30": get_sla_time(_dt, 30),
"sla_120": get_sla_time(_dt, 120),
"sla_480": get_sla_time(_dt, 480),
},
)
case.requires_action_at = _dt
case.save()
event = event_registry.get_event("case")()
with patch_field(Log, "created", _make_datetime(2015, 1, 2, 9, 30, 0)):
event.process(case, status="call_started", created_by=user, notes="Call started")
date_range = (_make_datetime(2015, 1, 1), _make_datetime(2015, 2, 1))
with mock.patch("reports.forms.MICB1Extract.date_range", date_range):
report = MICB1Extract()
qs = report.get_queryset()
self.assertFalse(qs[0][28])
def test_create_and_assign_agilisys_organisation(self):
organisation = make_recipe("call_centre.organisation", name="Agilisys")
make_recipe("call_centre.operator",
user=make_user(email="*****@*****.**"))
make_recipe("call_centre.operator",
user=make_user(email="*****@*****.**"))
make_recipe("call_centre.operator",
user=make_user(email="*****@*****.**"))
make_recipe("call_centre.operator",
user=make_user(email="*****@*****.**"),
organisation=organisation)
make_recipe("call_centre.operator",
user=make_user(email="*****@*****.**"))
make_recipe("call_centre.operator",
user=make_user(email="*****@*****.**"))
make_recipe("call_centre.operator",
user=make_user(email="*****@*****.**"))
out = StringIO()
call_command("create_and_assign_agilisys_organisation", stdout=out)
self.assertIn("Updating 2 Agilisys operators...done", out.getvalue())
def test_assign_existing_cases_to_organisation(self):
agilisys_org = make_recipe("call_centre.organisation", name="Agilisys")
foo_org = make_recipe("call_centre.organisation", name="Foo org")
agilisys_operator = make_recipe(
"call_centre.operator",
user=make_user(email="*****@*****.**"))
agilisys_case = make_recipe("legalaid.case",
created_by=agilisys_operator.user)
foo_org_case = make_recipe("legalaid.case", organisation=foo_org)
no_org_case = make_recipe("legalaid.case")
out = StringIO()
call_command("assign_existing_cases_to_organisation", stdout=out)
self.assertIn("2 cases found.", out.getvalue())
# Rerun command should result in no changes
call_command("assign_existing_cases_to_organisation", stdout=out)
self.assertIn("0 cases found.", out.getvalue())
# Cases without organisation should have their organisation set to Agilisys
case_reloaded = Case.objects.get(pk=no_org_case.id)
self.assertIsNotNone(case_reloaded.organisation)
self.assertEqual(case_reloaded.organisation.id, agilisys_org.id)
# Cases belonging to operators with an organisation should have case organisation
# set to that operators organisation
case_reloaded = Case.objects.get(pk=agilisys_case.id)
self.assertIsNotNone(case_reloaded.organisation)
self.assertEqual(case_reloaded.organisation.id, agilisys_org.id)
# Cases already belonging to an organisation should not have their organisation changed
case_reloaded = Case.objects.get(pk=foo_org_case.id)
self.assertIsNotNone(case_reloaded.organisation)
self.assertEqual(case_reloaded.organisation.id,
foo_org_case.organisation.id)
def setUp(self):
self.dummy_case = make_recipe("legalaid.case")
self.dummy_user = make_user()
def test_stops_timer(self, mocked_get_timer):
user = make_user()
stop_timer(user)
self.assertTrue(mocked_get_timer().stop.called, True)
def test_billable_time_with_2_stopped_timers(self, mocked_now):
"""
DB:
timer1: on case A, by user A, stopped
timer2: on case A, by user A, stopped by this test
timer3: on case A, by user B, stopped
timer4: on case A, by user B, running (should be ignored)
timer5: on case B, by user A, stopped (should be ignored)
timer6: on no case, by user A, cancelled (should be ignored)
Expected:
case A.billable_time == timer1 + timer2 + timer3
"""
def build_datetime(date_str):
dt = datetime.datetime.strptime(date_str, "%d/%m/%Y %H:%M:%S")
return dt.replace(tzinfo=timezone.get_current_timezone())
# DATABASE SETUP
caseA = make_recipe("legalaid.Case")
caseB = make_recipe("legalaid.Case")
userA = make_user()
userB = make_user()
make_recipe(
"timer.Timer",
created=build_datetime("01/01/2014 10:00:00"),
stopped=build_datetime("01/01/2014 10:00:01"),
linked_case=caseA,
created_by=userA,
)
timer2 = make_recipe(
"timer.Timer",
created=build_datetime("01/04/2014 11:00:00"),
stopped=None,
linked_case=caseA,
created_by=userA,
)
make_recipe(
"timer.Timer",
created=build_datetime("01/02/2014 23:00:00"),
stopped=build_datetime("02/02/2014 01:00:01"),
linked_case=caseA,
created_by=userB,
)
timer4 = make_recipe("timer.Timer", stopped=None, linked_case=caseA, created_by=userB)
make_recipe("timer.Timer", stopped=build_datetime("02/02/2014 01:00:01"), linked_case=caseB, created_by=userA)
make_recipe(
"timer.Timer",
stopped=build_datetime("02/02/2014 01:00:01"),
linked_case=caseB,
created_by=userA,
cancelled=True,
)
make_recipe("cla_eventlog.Log", timer=timer2, case=caseA)
make_recipe("cla_eventlog.Log", timer=timer4, case=caseA)
# CHECKS BEFORE STOPPING THE TIMER
self.assertEqual(caseA.billable_time, 0)
self.assertEqual(caseB.billable_time, 0)
mocked_now.return_value = build_datetime("01/04/2014 11:05:00")
timer2.stop()
# reloading objects
caseA = Case.objects.get(pk=caseA.pk)
caseB = Case.objects.get(pk=caseB.pk)
# CHECKING CALCULATED BILLABLE TIME
self.assertEqual(caseA.billable_time, 7502)
self.assertEqual(caseB.billable_time, 0)
def test_get_by_user_returns_timer(self):
user = make_user()
timer = make_recipe("timer.Timer", stopped=None, created_by=user)
self.assertEqual(Timer.running_objects.get_by_user(user), timer)
def setUp(self):
super(BaseCaseLogFormTestCaseMixin, self).setUp()
self.user = make_user()
created_by=user,
notes="Call started")
def get_report(self, date_range):
with mock.patch("reports.forms.MICB1Extract.date_range", date_range):
report = MICB1Extract()
qs = report.get_queryset()
headers = report.get_headers()
return {k: v for k, v in zip(headers, qs[0])}
def create_and_get_report(self, callback_minutes_after, case=None):
created = case.created if case else _make_datetime(2015, 1, 2, 9, 1, 0)
case = case or self.make_case(created)
user = make_user()
make_recipe("call_centre.operator", user=user)
requires_action_at = created + datetime.timedelta(
minutes=self.requires_action_at_minutes_offset)
self.schedule_callback(case, user, created, requires_action_at)
self.start_call(
case, user, requires_action_at +
datetime.timedelta(minutes=callback_minutes_after))
date_range = (
created.replace(hour=0, minute=0),
created.replace(hour=0, minute=0) + datetime.timedelta(days=1),
)
return self.get_report(date_range)
def test_get_by_user_fails_when_no_timer(self):
user = make_user()
make_recipe("timer.Timer", stopped=timezone.now(), created_by=user)
self.assertRaises(IndexError, Timer.running_objects.get_by_user, user)
def test_stops_timer(self, mocked_get_timer):
user = make_user()
stop_timer(user)
self.assertTrue(mocked_get_timer().stop.called, True)
class MiSlaTestCaseWeb(MiSlaTestCaseBase, TestCase):
source = CASE_SOURCE.WEB
# fmt: off
"""
CB1
+--------------+-------------------------------+---------------------------------------------+--------------------------------+
| | | | Call answered |
| | | | after 30m |
| | Call answered | Call answered | AND |
| | Within 30m window | before 30m window | current time within 72h window |
+--------------+-------------------------------+---------------------------------------------+--------------------------------+
| SLA 1 missed | FALSE | TRUE | TRUE |
+--------------+-------------------------------+---------------------------------------------+--------------------------------+
| SLA 2 missed | FALSE | FALSE | FALSE |
+--------------+-------------------------------+---------------------------------------------+--------------------------------+
| test | test_current_time_within_sla1 | test_current_time_before_requires_action_at | test_current_time_after_sla1 |
+--------------+-------------------------------+---------------------------------------------+--------------------------------+
CB2
+--------------+-----------------------------------+-------------------------------------------------+----------------------------------+----------------------------------+----------------------------------+-----------------------------------+
| | CB2 Scheduled | CB2 Scheduled | CB2 Scheduled | CB2 Scheduled | Call answered | CB2 Scheduled |
| | within 30m window | before 30m window | after 30m window | after 30m window | after 72 window | within 30m window |
| | AND | AND | AND | AND | | AND |
| | current time within 72h window | current time within 72h window | current time within 72h window | current time after 72h window | | call answered within 72 window |
+--------------+-----------------------------------+-------------------------------------------------+----------------------------------+----------------------------------+----------------------------------+-----------------------------------+
| SLA 1 missed | FALSE | TRUE | TRUE | TRUE | TRUE | FALSE |
+--------------+-----------------------------------+-------------------------------------------------+----------------------------------+----------------------------------+----------------------------------+-----------------------------------+
| SLA 2 missed | FALSE | FALSE | FALSE | TRUE | TRUE | FALSE |
+--------------+-----------------------------------+-------------------------------------------------+----------------------------------+----------------------------------+----------------------------------+-----------------------------------+
| test | test_cb2_current_time_within_sla1 | test_cb2_current_time_before_requires_action_at | test_cb2_current_time_after_sla1 | test_cb2_current_time_after_sla2 | test_cb2_current_time_after_sla2 | test_cb2_current_time_within_sla1 |
+--------------+-----------------------------------+-------------------------------------------------+----------------------------------+----------------------------------+----------------------------------+-----------------------------------+
CB3
+--------------+-----------------------------------+
| | CB3 Scheduled |
| | within 30m window |
| | AND |
| | call answered within 72 window |
+--------------+-----------------------------------+
| SLA 1 missed | FALSE |
+--------------+-----------------------------------+
| SLA 2 missed | FALSE |
+--------------+-----------------------------------+
| test | test_cb3_current_time_within_sla1 |
+--------------+-----------------------------------+
"""
# fmt: on
def get_default_dt(self):
return _make_datetime(year=2020, month=9, day=7, hour=9, minute=0)
def get_requires_action_at(self):
return self.now + datetime.timedelta(hours=1)
def get_sla1_datetime(self):
return self.get_requires_action_at() + datetime.timedelta(minutes=30)
def get_sla2_datetime(self):
return _make_datetime(year=2020, month=9, day=15, hour=12, minute=30)
def test_current_time_before_requires_action_at(self):
case = self.make_case(self.now, created=self.now)
user = make_user()
make_recipe("call_centre.operator", user=user)
# Create a callback that is due now 1 hour from now
requires_action_at = self.get_requires_action_at()
self.schedule_callback(case,
user,
created=self.now,
requires_action_at=requires_action_at)
# Move current time to 5 minute before requires_action_at
self._move_time_forward(requires_action_at, minutes_forward=-5)
# Generate report without a callback
date_range = (self.now - datetime.timedelta(days=2),
self.now + datetime.timedelta(days=2))
values = self.get_report(date_range)
self.assertFalse(values["missed_sla_1"])
self.assertFalse(values["missed_sla_2"])
# Start a call
self.start_call(case, user, self.now)
# Generate report with a successful callback
date_range = (self.now - datetime.timedelta(days=2),
self.now + datetime.timedelta(days=2))
values = self.get_report(date_range)
# Contacting customer before the requires_action_at will result in a failure to meet SLA
self.assertTrue(values["missed_sla_1"])
self.assertFalse(values["missed_sla_2"])
def setUp(self):
super(BaseCaseLogFormTestCaseMixin, self).setUp()
self.user = make_user()
def setUp(self):
super(BaseEventTestCase, self).setUp()
self.dummy_case = make_recipe("legalaid.case")
self.dummy_user = make_user()
