def test_CALLBACK_COMPLETE(self):
# with callback_attempt == 1
case = make_recipe("legalaid.case", callback_attempt=1)
self._test_process_with_implicit_code(
"CALLBACK_COMPLETE",
dummy_case=case,
expected_type=LOG_TYPES.SYSTEM,
expected_level=LOG_LEVELS.HIGH,
process_kwargs={"complete": True},
)
# with callback_attempt == 2
case = make_recipe("legalaid.case", callback_attempt=2)
self._test_process_with_implicit_code(
"CALLBACK_COMPLETE",
dummy_case=case,
expected_type=LOG_TYPES.SYSTEM,
expected_level=LOG_LEVELS.HIGH,
process_kwargs={"complete": True},
)
# with callback_attempt == 3
case = make_recipe("legalaid.case", callback_attempt=3)
self._test_process_with_implicit_code(
"CALLBACK_COMPLETE",
dummy_case=case,
expected_type=LOG_TYPES.SYSTEM,
expected_level=LOG_LEVELS.HIGH,
process_kwargs={"complete": True},
)
def test_CASE_VIEWED_log_not_created_after_CASE_VIEWED_during_timer(self):
"""
During the lifetime of a timer, if a user viewed a case twice, we
should only log CASE_VIEWED once.
"""
event = event_registry.get_event(self.EVENT_KEY)()
self.assertEqual(Log.objects.count(), 0) # no logs
# db setup
make_recipe('timer.Timer', created_by=self.dummy_user)
# case viewed
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'viewed'
})
self.assertEqual(Log.objects.count(), 1)
# case viewed log not created because case created log
# already exists
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'viewed'
})
self.assertEqual(Log.objects.count(), 1)
def test_create_with_data(self):
media_code = make_recipe('legalaid.media_code')
matter_type1 = make_recipe('legalaid.matter_type1')
matter_type2 = make_recipe('legalaid.matter_type2')
data = {
'notes': 'my notes',
'matter_type1': matter_type1.code,
'matter_type2': matter_type2.code,
'media_code': media_code.code,
'source': CASE_SOURCE.VOICEMAIL,
'provider_notes': "bla",
}
response = self.client.post(
self.list_url, data=data, format='json',
HTTP_AUTHORIZATION='Bearer %s' % self.token
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertResponseKeys(response)
self.assertCaseEqual(response.data,
Case(
reference=response.data['reference'],
notes=data['notes'],
matter_type1=matter_type1,
matter_type2=matter_type2,
media_code=media_code,
source=CASE_SOURCE.VOICEMAIL,
provider_notes="",
laa_reference=response.data['laa_reference'],
)
)
self.assertLogInDB()
def test_CASE_VIEWED_log_not_created_after_CASE_CREATED_during_timer(self):
"""
During the lifetime of a timer, if a user creates a case
and then views it, only 'CASE_CREATED' log is created.
In other words, we don't log 'CASE_VIEWED' to avoid noise.
"""
event = event_registry.get_event(self.EVENT_KEY)()
self.assertEqual(Log.objects.count(), 0) # no logs
# db setup
make_recipe("timer.Timer", created_by=self.dummy_user)
# case created
event.process(
**{
"case": self.dummy_case,
"created_by": self.dummy_user,
"status": "created"
})
self.assertEqual(Log.objects.count(), 1)
# case viewed log not created because case created log
# already exists
event.process(
**{
"case": self.dummy_case,
"created_by": self.dummy_user,
"status": "viewed"
})
self.assertEqual(Log.objects.count(), 1)
def test_create_basic_data(self):
"""
CREATE data is not empty
"""
make_recipe('legalaid.category')
category = Category.objects.all()[0]
data={
'category': category.code,
'your_problem_notes': 'lorem',
'dependants_young': 2,
'dependants_old': 3,
}
response = self._create(data=data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertResponseKeys(response)
self.assertTrue(len(response.data['reference']) > 30)
self.assertEligibilityCheckEqual(response.data,
EligibilityCheck(
reference=response.data['reference'], category=category,
your_problem_notes=data['your_problem_notes'],
dependants_young=data['dependants_young'],
dependants_old=data['dependants_old']
)
)
def test_create_basic_data_with_extras(self):
"""
CREATE data includes random values for fields:
`has_partner`, `is_you_or_your_partner_over_60`, `on_passported_benefits`
Where the possible values are: [`True`, `False`, `None`]
"""
make_recipe('legalaid.category')
category = Category.objects.all()[0]
data= {
'category': category.code,
'your_problem_notes': 'lorem',
'has_partner': random.choice([None, True, False]),
'is_you_or_your_partner_over_60': random.choice([None, True, False]),
'on_passported_benefits': random.choice([None, True, False]),
'specific_benefits': None
}
response = self._create(data=data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertResponseKeys(response)
self.assertTrue(len(response.data['reference']) > 30)
self.assertEligibilityCheckEqual(response.data,
EligibilityCheck(
reference=response.data['reference'],
category=category,
your_problem_notes=data['your_problem_notes'],
has_partner=data['has_partner'],
is_you_or_your_partner_over_60=data['is_you_or_your_partner_over_60'],
on_passported_benefits=data['on_passported_benefits'],
specific_benefits=None,
)
)
def test_delete_old_data_run_case_under_two_years_unsuccessful_delete(
self):
log = make_recipe("cla_auditlog.audit_log")
# Creating a case using current timestamp
case = make_recipe("legalaid.case", audit_log=[log])
eod = make_recipe("legalaid.eod_details", case=case)
make_recipe("complaints.complaint", eod=eod, audit_log=[log])
pks = get_pks(Case.objects.all())
eods = EODDetails.objects.filter(case_id__in=pks).values_list(
"pk", flat=True)
self.assertEqual(len(Case.objects.all()), 1)
self.assertEqual(len(AuditLog.objects.filter(case__in=pks)), 1)
self.assertEqual(len(EODDetails.objects.all()), 1)
self.assertEqual(len(Complaint.objects.all()), 1)
case_complaints = Complaint.objects.filter(
eod_id__in=eods).values_list("pk", flat=True)
self.assertEqual(
len(AuditLog.objects.filter(complaint__in=case_complaints)), 1)
self.delete_old_data.run()
self.assertEqual(len(Case.objects.all()), 1)
self.assertEqual(len(AuditLog.objects.filter(case__in=pks)), 1)
self.assertEqual(len(EODDetails.objects.all()), 1)
self.assertEqual(len(Complaint.objects.all()), 1)
case_complaints = Complaint.objects.filter(
eod_id__in=eods).values_list("pk", flat=True)
self.assertEqual(
len(AuditLog.objects.filter(complaint__in=case_complaints)), 1)
def test_get_suggested_provider_rota(self):
as_of = timezone.make_aware(
datetime.datetime(day=7, month=12, year=2014, hour=10, minute=0), timezone.get_current_timezone()
)
category = make_recipe("legalaid.category")
provider = make_recipe("cla_provider.provider", active=True)
make_recipe(
"cla_provider.outofhoursrota",
provider=provider,
start_date=as_of,
end_date=as_of + datetime.timedelta(days=1),
category=category,
)
helper = ProviderAllocationHelper(as_of=as_of)
choosen_provider = helper.get_suggested_provider(category)
self.assertEqual(choosen_provider, provider)
# Set cat1_provider2.active == False => only one prov returned
provider.active = False
provider.save()
helper = ProviderAllocationHelper(as_of=as_of)
choosen_provider = helper.get_suggested_provider(category)
self.assertEqual(choosen_provider, None)
def test_CASE_VIEWED_log_not_created_after_CASE_CREATED_during_timer(self):
"""
During the lifetime of a timer, if a user creates a case
and then views it, only 'CASE_CREATED' log is created.
In other words, we don't log 'CASE_VIEWED' to avoid noise.
"""
event = event_registry.get_event(self.EVENT_KEY)()
self.assertEqual(Log.objects.count(), 0) # no logs
# db setup
make_recipe('timer.Timer', created_by=self.dummy_user)
# case created
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'created'
})
self.assertEqual(Log.objects.count(), 1)
# case viewed log not created because case created log
# already exists
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'viewed'
})
self.assertEqual(Log.objects.count(), 1)
def test_save_sets_is_staff_True_if_is_manager_or_is_cla_superuser_True(self):
# is_manager = True
operator = make_recipe("call_centre.operator", is_manager=True, user__is_staff=False)
self.assertTrue(operator.is_manager)
self.assertTrue(operator.user.is_staff)
# setting again user.is_staff to False but keeping is_manager True
# => user.is_staff should still be True
operator.user.is_staff = False
operator.user.save()
operator.save()
self.assertTrue(operator.user.is_staff)
# is_cla_superuser = True
operator = make_recipe("call_centre.operator", is_cla_superuser=True, user__is_staff=False)
self.assertTrue(operator.is_cla_superuser)
self.assertTrue(operator.user.is_staff)
# setting again user.is_staff to False but keeping is_cla_superuser True
# => user.is_staff should still be True
operator.user.is_staff = False
operator.user.save()
operator.save()
self.assertTrue(operator.user.is_staff)
def test_save_sets_is_staff_True_if_is_manager_or_is_cla_superuser_True(
self):
# is_manager = True
operator = make_recipe("call_centre.operator",
is_manager=True,
user__is_staff=False)
self.assertTrue(operator.is_manager)
self.assertTrue(operator.user.is_staff)
# setting again user.is_staff to False but keeping is_manager True
# => user.is_staff should still be True
operator.user.is_staff = False
operator.user.save()
operator.save()
self.assertTrue(operator.user.is_staff)
# is_cla_superuser = True
operator = make_recipe("call_centre.operator",
is_cla_superuser=True,
user__is_staff=False)
self.assertTrue(operator.is_cla_superuser)
self.assertTrue(operator.user.is_staff)
# setting again user.is_staff to False but keeping is_cla_superuser True
# => user.is_staff should still be True
operator.user.is_staff = False
operator.user.save()
operator.save()
self.assertTrue(operator.user.is_staff)
def test_CASE_VIEWED_log_not_created_after_CASE_VIEWED_during_timer(self):
"""
During the lifetime of a timer, if a user viewed a case twice, we
should only log CASE_VIEWED once.
"""
event = event_registry.get_event(self.EVENT_KEY)()
self.assertEqual(Log.objects.count(), 0) # no logs
# db setup
make_recipe("timer.Timer", created_by=self.dummy_user)
# case viewed
event.process(
**{
"case": self.dummy_case,
"created_by": self.dummy_user,
"status": "viewed"
})
self.assertEqual(Log.objects.count(), 1)
# case viewed log not created because case created log
# already exists
event.process(
**{
"case": self.dummy_case,
"created_by": self.dummy_user,
"status": "viewed"
})
self.assertEqual(Log.objects.count(), 1)
def test_create_then_patch_category(self):
"""
PATCHED category is applied
"""
make_recipe("legalaid.category", _quantity=2)
category = Category.objects.all()[0]
category2 = Category.objects.all()[1]
# CREATING FIRST
data = {"category": category.code, "your_problem_notes": "lorem", "dependants_young": 2, "dependants_old": 3}
response = self._create(data=data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# NOW PATCHING
reference = self.get_reference_from_response(response.data)
data["category"] = category2.code
patch_response = self._update(reference, data=data)
self.assertEqual(patch_response.status_code, status.HTTP_200_OK)
self.assertResponseKeys(patch_response)
self.assertEligibilityCheckEqual(
patch_response.data,
EligibilityCheck(
reference=response.data["reference"],
category=category2,
your_problem_notes=data["your_problem_notes"],
dependants_young=data["dependants_young"],
dependants_old=data["dependants_old"],
),
)
def setUp(self):
super(SplitCaseFormTestCase, self).setUp()
self.cat1_data = self.build_category_data()
self.cat2_data = self.build_category_data()
self.cat3_data = self.build_category_data()
self.provider = make_recipe(
'cla_provider.provider', law_category=[
self.cat1_data.category, self.cat2_data.category,
]
)
self.request = mock.MagicMock(
user=mock.MagicMock(
staff=mock.MagicMock(
provider=self.provider
)
)
)
self.eligibility_check = make_recipe(
'legalaid.eligibility_check',
category=self.cat1_data.category
)
self.case = make_recipe(
'legalaid.case', provider=self.provider,
requires_action_by=REQUIRES_ACTION_BY.PROVIDER,
eligibility_check=self.eligibility_check,
matter_type1=self.cat1_data.matter_type1,
matter_type2=self.cat1_data.matter_type2
)
def test_get_suggested_provider_random(self):
as_of = timezone.make_aware(
datetime.datetime(day=8, month=12, year=2014, hour=10, minute=0),
timezone.get_current_timezone())
category = make_recipe("legalaid.category")
provider = make_recipe("cla_provider.provider", active=True)
make_recipe("cla_provider.provider_allocation",
weighted_distribution=0.5,
provider=provider,
category=category)
helper = ProviderAllocationHelper(as_of=as_of)
choosen_provider = helper._get_random_provider(category)
self.assertEqual(choosen_provider, provider)
# Set cat1_provider2.active == False => only one prov returned
provider.active = False
provider.save()
helper = ProviderAllocationHelper(as_of=as_of)
choosen_provider = helper.get_suggested_provider(category)
self.assertEqual(choosen_provider, None)
def test_update_with_data(self):
media_code = make_recipe('legalaid.media_code')
matter_type1 = make_recipe('legalaid.matter_type1')
matter_type2 = make_recipe('legalaid.matter_type2')
data = {
'matter_type1': matter_type1.code,
'matter_type2': matter_type2.code,
'media_code': media_code.code,
'source': CASE_SOURCE.VOICEMAIL
}
response = self.client.patch(
self.detail_url, data=data,
HTTP_AUTHORIZATION=self.get_http_authorization()
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertResponseKeys(response)
case = self.resource
case.matter_type1 = matter_type1
case.matter_type2 = matter_type2
case.media_code = media_code
case.source = CASE_SOURCE.VOICEMAIL
self.assertCaseEqual(response.data, case)
self.assertNoLogInDB()
def setUp(self):
super(OutOfHoursRotaTests, self).setUp()
self.operator.is_manager = True
self.operator.save()
self.categories = make_recipe("legalaid.category", _quantity=3)
self.providers = make_recipe(
"cla_provider.provider", active=True, law_category=list(self.categories), _quantity=3
)
self.rotas = []
category_generator = cycle(list(self.categories))
start_date = timezone.now()
for provider in self.providers:
end_date = start_date + timedelta(days=7)
self.rotas.append(
make_recipe(
"cla_provider.outofhoursrota",
provider=provider,
start_date=start_date,
end_date=end_date,
category=next(category_generator),
)
)
start_date = end_date
self.list_url = reverse("call_centre:outofhoursrota-list")
self.provider_list_url = reverse("call_centre:provider-list")
self.detail_url = reverse("call_centre:outofhoursrota-detail", args=(), kwargs={"pk": self.rotas[0].pk})
def test_invalid_datetime(self):
def to_utc_date(days_delta, **replace_params):
# if this fails remove the pytz module
# from localtime to utc (that's because of BST)
dt = timezone.localtime(timezone.now())
dt += datetime.timedelta(days=days_delta-dt.weekday())
dt = dt.replace(**replace_params)
return timezone.localtime(dt, timezone.utc)
case = make_recipe('legalaid.case')
self.assertEqual(Log.objects.count(), 0)
def _test(case, datetime, error_msg):
data = self.get_default_data()
data['datetime'] = datetime
form = self.FORM(case=case, data=data)
self.assertFalse(form.is_valid())
self.assertEqual(len(form.errors), 1)
self.assertItemsEqual(
form.errors['datetime'], [error_msg]
)
# nothing has changed
case = Case.objects.get(pk=case.pk)
self.assertEqual(Log.objects.count(), 0)
def test_get_suggested_provider_rota(self):
as_of = timezone.make_aware(
datetime.datetime(day=7, month=12, year=2014, hour=10, minute=0),
timezone.get_current_timezone())
category = make_recipe("legalaid.category")
provider = make_recipe("cla_provider.provider", active=True)
make_recipe(
"cla_provider.outofhoursrota",
provider=provider,
start_date=as_of,
end_date=as_of + datetime.timedelta(days=1),
category=category,
)
helper = ProviderAllocationHelper(as_of=as_of)
choosen_provider = helper.get_suggested_provider(category)
self.assertEqual(choosen_provider, provider)
# Set cat1_provider2.active == False => only one prov returned
provider.active = False
provider.save()
helper = ProviderAllocationHelper(as_of=as_of)
choosen_provider = helper.get_suggested_provider(category)
self.assertEqual(choosen_provider, None)
def test_save_without_matter_type_both(self, timezone_mock,
models_timezone_mock):
_mock_datetime_now_with(datetime.datetime(2014, 1, 2, 12, 59, 0),
timezone_mock, models_timezone_mock)
case = make_recipe("legalaid.case")
category = case.eligibility_check.category
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.assertFalse(form.is_valid())
self.assertDictEqual(
form.errors,
{
"__all__": [
u"Can't assign to specialist provider without setting matter_type1 and matter_type2"
]
},
)
def test_create_with_data(self):
media_code = make_recipe('legalaid.media_code')
matter_type1 = make_recipe('legalaid.matter_type1')
matter_type2 = make_recipe('legalaid.matter_type2')
data = {
'notes': 'my notes',
'matter_type1': matter_type1.code,
'matter_type2': matter_type2.code,
'media_code': media_code.code,
'source': CASE_SOURCE.VOICEMAIL,
'provider_notes': "bla",
}
response = self.client.post(self.list_url,
data=data,
format='json',
HTTP_AUTHORIZATION='Bearer %s' %
self.token)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertResponseKeys(response)
self.assertCaseEqual(
response.data,
Case(
reference=response.data['reference'],
notes=data['notes'],
matter_type1=matter_type1,
matter_type2=matter_type2,
media_code=media_code,
source=CASE_SOURCE.VOICEMAIL,
provider_notes="",
laa_reference=response.data['laa_reference'],
))
self.assertLogInDB()
def test_operator_listing(self):
foo_org = make_recipe("call_centre.organisation",
name="Organisation Foo")
bar_org = make_recipe("call_centre.organisation",
name="Organisation Bar")
operators = self._assign_operators_to_organisation(foo_org, bar_org)
self.operator_manager.organisation = bar_org
self.operator_manager.save()
operators["bar_org"].append(self.operator_manager.user.username)
self.operator.organisation = bar_org
self.operator.save()
operators["bar_org"].append(self.operator.user.username)
url = reverse("%s:user-list" % self.API_URL_NAMESPACE)
response = self.client.get(
url,
HTTP_AUTHORIZATION=self.get_http_authorization(
token=self.manager_token))
for operator in response.data:
self.assertNotIn(operator["username"], operators["foo_org"])
self.assertIn(operator["username"],
operators["bar_org"] + operators["no_org"])
def test_delete_old_data_run_case_over_two_years_successful_delete(self):
log = make_recipe("cla_auditlog.audit_log")
# Creating a case thats three years old so it gets picked up properly by the delete data
freezer = freeze_time(timezone.now() + relativedelta(years=-3))
freezer.start()
case = make_recipe("legalaid.case", audit_log=[log])
freezer.stop()
eod = make_recipe("legalaid.eod_details", case=case)
make_recipe("complaints.complaint", eod=eod, audit_log=[log])
pks = get_pks(Case.objects.all())
eods = EODDetails.objects.filter(case_id__in=pks).values_list(
"pk", flat=True)
self.assertEqual(len(Case.objects.all()), 1)
self.assertEqual(len(AuditLog.objects.filter(case__in=pks)), 1)
self.assertEqual(len(EODDetails.objects.all()), 1)
self.assertEqual(len(Complaint.objects.all()), 1)
case_complaints = Complaint.objects.filter(
eod_id__in=eods).values_list("pk", flat=True)
self.assertEqual(
len(AuditLog.objects.filter(complaint__in=case_complaints)), 1)
self.delete_old_data.run()
self.assertEqual(len(Case.objects.all()), 0)
self.assertEqual(len(AuditLog.objects.filter(case__in=pks)), 0)
self.assertEqual(len(EODDetails.objects.all()), 0)
self.assertEqual(len(Complaint.objects.all()), 0)
case_complaints = Complaint.objects.filter(
eod_id__in=eods).values_list("pk", flat=True)
self.assertEqual(
len(AuditLog.objects.filter(complaint__in=case_complaints)), 0)
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_migrate_no_message_to_safe_to_contact(self):
personal_details_safe = make_recipe(
"legalaid.personal_details", safe_to_contact=CONTACT_SAFETY.SAFE, _quantity=2
)
personal_details_no_call = make_recipe(
"legalaid.personal_details", safe_to_contact=CONTACT_SAFETY.DONT_CALL, _quantity=2
)
personal_details_no_message = make_recipe(
"legalaid.personal_details", safe_to_contact="NO_MESSAGE", _quantity=3
)
__import__("legalaid.migrations.0026_safe_to_contact_remove_no_message")
migration = getattr(legalaid.migrations, "0026_safe_to_contact_remove_no_message")
apps_mock = mock.Mock()
apps_mock.get_model = mock.MagicMock(return_value=PersonalDetails)
migration.migrate_no_message_to_safe_to_contact(apps_mock, None)
personal_details = personal_details_safe + personal_details_no_message
for personal_detail in personal_details:
personal_detail = PersonalDetails.objects.get(pk=personal_detail.pk)
self.assertEqual(personal_detail.safe_to_contact, CONTACT_SAFETY.SAFE)
for personal_detail in personal_details_no_call:
personal_detail = PersonalDetails.objects.get(pk=personal_detail.pk)
self.assertEqual(personal_detail.safe_to_contact, CONTACT_SAFETY.DONT_CALL)
self.assertEqual(PersonalDetails.objects.filter(safe_to_contact="NO_MESSAGE").count(), 0)
def test_save(self):
self.assertEqual(Article.objects.count(), 0)
self.assertEqual(TelephoneNumber.objects.count(), 0)
self.assertEqual(ArticleCategoryMatrix.objects.count(), 0)
make_recipe("knowledgebase.article_category", name="Employment")
make_recipe("knowledgebase.article_category", name="Discrimination")
article = self.importer.get_article_from_row(self.row)
telephone_numbers = self.importer.get_telephone_numbers_from_row(
article, self.row)
article_category_matrices = self.importer.get_article_category_matrices_from_row(
article, self.row)
rows = [{
"article": article,
"telephone_numbers": telephone_numbers,
"article_category_matrices": article_category_matrices,
}]
self.importer.save(rows)
self.assertEqual(Article.objects.count(), 1)
self.assertEqual(article.article_category.count(), 2)
self.assertEqual(
TelephoneNumber.objects.filter(article=article).count(), 2)
def setUp(self):
super(NotificationAPIMixin, self).setUp()
self.notifications = make_recipe("notifications.notification",
_quantity=2)
make_recipe("notifications.notification_out_of_time", _quantity=2)
def test_save_without_matter_type_only_mt1(self, timezone_mock,
models_timezone_mock):
_mock_datetime_now_with(datetime.datetime(2014, 1, 2, 12, 59, 0),
timezone_mock, models_timezone_mock)
case = make_recipe('legalaid.case')
category = case.eligibility_check.category
provider = make_recipe('cla_provider.provider', active=True)
make_recipe('cla_provider.provider_allocation',
weighted_distribution=0.5,
provider=provider,
category=category)
case.matter_type1 = make_recipe('legalaid.matter_type1',
category=category)
case.save()
helper = ProviderAllocationHelper()
form = ProviderAllocationForm(case=case, data={
'provider': helper.get_suggested_provider(category).pk},
providers=helper.get_qualifying_providers(
category))
self.assertFalse(form.is_valid())
self.assertDictEqual(form.errors, {'__all__': [
u"Can't assign to specialist provider without setting matter_type1 and matter_type2"]})
def test_callback_VOICEMAIL_sla_date_from_case_creation_date(
self, mocked_now):
# When case.source is VOICEMAIL then sla offset should be from case.created field
# rather than the requires_action_at field
mocked_now.return_value = self.mocked_now.return_value
created = timezone.localtime(self.default_dt,
timezone.get_default_timezone())
case = make_recipe("legalaid.case",
created=created,
source=CASE_SOURCE.VOICEMAIL)
self._test_save_successfull(case,
1,
"CB1",
skip_assert_log_context=True)
requires_action_at = timezone.localtime(
case.requires_action_at, timezone.get_default_timezone())
log = Log.objects.filter().last()
self.assertDictEqual(
log.context,
{
"requires_action_at":
requires_action_at.isoformat(),
"sla_120":
(case.created + datetime.timedelta(minutes=120)).isoformat(),
"sla_480":
(case.created + datetime.timedelta(hours=8)).isoformat(),
"sla_15":
(case.created + datetime.timedelta(minutes=15)).isoformat(),
"sla_30":
(case.created + datetime.timedelta(minutes=30)).isoformat(),
"sla_72h":
timezone.make_aware(self.expected_sla_72h,
created.tzinfo).isoformat(),
},
)
def setUp(self):
super(OutOfHoursRotaTests, self).setUp()
self.operator.is_manager = True
self.operator.save()
self.categories = make_recipe("legalaid.category", _quantity=3)
self.providers = make_recipe("cla_provider.provider",
active=True,
law_category=list(self.categories),
_quantity=3)
self.rotas = []
category_generator = cycle(list(self.categories))
start_date = timezone.now()
for provider in self.providers:
end_date = start_date + timedelta(days=7)
self.rotas.append(
make_recipe(
"cla_provider.outofhoursrota",
provider=provider,
start_date=start_date,
end_date=end_date,
category=next(category_generator),
))
start_date = end_date
self.list_url = reverse("call_centre:outofhoursrota-list")
self.provider_list_url = reverse("call_centre:provider-list")
self.detail_url = reverse("call_centre:outofhoursrota-detail",
args=(),
kwargs={"pk": self.rotas[0].pk})
def test_update_with_data(self):
media_code = make_recipe("legalaid.media_code")
matter_type1 = make_recipe("legalaid.matter_type1")
matter_type2 = make_recipe("legalaid.matter_type2")
data = {
"matter_type1": matter_type1.code,
"matter_type2": matter_type2.code,
"media_code": media_code.code,
"source": CASE_SOURCE.VOICEMAIL,
}
response = self.client.patch(
self.detail_url,
data=data,
HTTP_AUTHORIZATION=self.get_http_authorization())
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertResponseKeys(response)
case = self.resource
case.matter_type1 = matter_type1
case.matter_type2 = matter_type2
case.media_code = media_code
case.source = CASE_SOURCE.VOICEMAIL
self.assertCaseEqual(response.data, case)
self.assertNoLogInDB()
def test_get_list(self):
Case.objects.all().delete()
now = timezone.now()
start_of_day = now.replace(hour=0, minute=0, second=0, microsecond=0)
# ref1.requires_action_at == past => EXCLUDED
# ref2.requires_action_at == None => EXCLUDED
# ref3.requires_action_at == start_of_day+7 => INCLUDED
# ref4.requires_action_at > start_of_day+7 => EXCLUDED
# ref5.requires_action_at == start_of_day => INCLUDED
make_recipe("legalaid.case", reference="ref1", requires_action_at=start_of_day - datetime.timedelta(seconds=1))
make_recipe("legalaid.case", reference="ref2", requires_action_at=None)
make_recipe(
"legalaid.case",
reference="ref3",
requires_action_at=start_of_day + datetime.timedelta(days=7) - datetime.timedelta(seconds=1),
)
make_recipe("legalaid.case", reference="ref4", requires_action_at=start_of_day + datetime.timedelta(days=7))
make_recipe("legalaid.case", reference="ref5", requires_action_at=start_of_day)
# searching
url = reverse("call_centre:case-future-callbacks")
response = self.client.get(url, format="json", HTTP_AUTHORIZATION="Bearer %s" % self.token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(2, len(response.data))
self.assertItemsEqual([case["reference"] for case in response.data], ["ref5", "ref3"])
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_create_with_data(self):
media_code = make_recipe("legalaid.media_code")
matter_type1 = make_recipe("legalaid.matter_type1")
matter_type2 = make_recipe("legalaid.matter_type2")
data = {
"notes": "my notes",
"matter_type1": matter_type1.code,
"matter_type2": matter_type2.code,
"media_code": media_code.code,
"source": CASE_SOURCE.VOICEMAIL,
"provider_notes": "bla",
}
response = self.client.post(
self.list_url, data=data, format="json", HTTP_AUTHORIZATION="Bearer %s" % self.token
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertResponseKeys(response)
self.assertCaseEqual(
response.data,
Case(
reference=response.data["reference"],
notes=data["notes"],
matter_type1=matter_type1,
matter_type2=matter_type2,
media_code=media_code,
source=CASE_SOURCE.VOICEMAIL,
provider_notes="",
laa_reference=response.data["laa_reference"],
),
)
self.assertLogInDB()
def test_query_set(self):
timer1 = make_recipe('timer.Timer', stopped=None)
timer2 = make_recipe('timer.Timer', stopped=timezone.now())
timer3 = make_recipe('timer.Timer', stopped=None)
timer4 = make_recipe('timer.Timer', cancelled=True)
timers = Timer.running_objects.all()
self.assertItemsEqual(timers, [timer1, timer3])
def __init__(self):
self.category = make_recipe('legalaid.category')
self.matter_type1 = make_recipe(
'legalaid.matter_type1', category=self.category
)
self.matter_type2 = make_recipe(
'legalaid.matter_type2', category=self.category
)
def _test_assign_successful(self, case, category, tz_model_mock, tz_helper_tz, is_manual=True):
fake_day = datetime.datetime(2014, 1, 2, 9, 1, 0).replace(tzinfo=timezone.get_current_timezone())
tz_model_mock.return_value = fake_day
tz_helper_tz.return_value = fake_day
case.matter_type1 = make_recipe("legalaid.matter_type1", category=category)
case.matter_type2 = make_recipe("legalaid.matter_type2", category=category)
case.save()
# preparing for test
provider = make_recipe("cla_provider.provider", name="Provider Name", active=True)
make_recipe(
"cla_provider.provider_allocation", weighted_distribution=0.5, provider=provider, category=category
)
# before being assigned, case is in the list
case_list = self.client.get(self.list_url, format="json", HTTP_AUTHORIZATION="Bearer %s" % self.token).data
self.assertTrue(case.reference in [x.get("reference") for x in case_list["results"]])
# no outcome codes should exist at this point
self.assertEqual(Log.objects.count(), 0)
# assign
url = reverse("call_centre:case-assign", args=(), kwargs={"reference": case.reference})
data = {"suggested_provider": provider.pk, "provider_id": provider.pk, "is_manual": is_manual}
if is_manual:
data["notes"] = "my notes"
response = self.client.post(url, data=data, HTTP_AUTHORIZATION="Bearer %s" % self.token, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
case = Case.objects.get(pk=case.pk)
self.assertIsNotNone(case.provider.pk)
# after being assigned, it's gone from the dashboard...
case_list = self.client.get(
self.list_dashboard_url, format="json", HTTP_AUTHORIZATION="Bearer %s" % self.token
).data
self.assertFalse(case.reference in [x.get("reference") for x in case_list["results"]])
# checking that requires_action_by is set to PROVIDER
self.assertEqual(case.requires_action_by, REQUIRES_ACTION_BY.PROVIDER_REVIEW)
# checking that the log object is there
self.assertEqual(Log.objects.count(), 1)
log = Log.objects.all()[0]
self.assertEqual(log.case, case)
self.assertEqual(log.notes, "Assigned to Provider Name. %s" % data.get("notes", ""))
self.assertEqual(log.created_by, self.user)
# ... but the case still accessible from the full list
case_list = self.client.get(self.list_url, format="json", HTTP_AUTHORIZATION="Bearer %s" % self.token).data
self.assertTrue(case.reference in [x.get("reference") for x in case_list["results"]])
def test_get_not_found_if_not_belonging_to_provider(self):
check = make_recipe("legalaid.eligibility_check")
check_case = make_recipe(
"legalaid.case", eligibility_check=check, provider=None, requires_action_by=REQUIRES_ACTION_BY.OPERATOR
)
detail_url = self.get_detail_url(check_case.reference)
response = self.client.get(detail_url, format="json", HTTP_AUTHORIZATION=self.get_http_authorization())
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_list_with_dashboard_param(self):
"""
Testing that if ?dashboard param is specified, it will exclude cases
that are already assigned or don't requires_action_by == OPERATOR
"""
Case.objects.all().delete()
now = timezone.now()
# obj1 is assigned => EXCLUDED
# obj2.requires_action_by == None (meaning doesn't require action) => EXCLUDED
# obj3.requires_action_by == OPERATOR => INCLUDED
# obj4.requires_action_at > now => EXCLUDED
# obj5.requires_action_at < now => INCLUDED
obj1 = make_recipe('legalaid.case',
reference='ref1',
provider=self.provider,
requires_action_by=REQUIRES_ACTION_BY.PROVIDER)
obj2 = make_recipe('legalaid.case',
reference='ref2',
provider=None,
requires_action_by=None)
obj3 = make_recipe('legalaid.case',
reference='ref3',
provider=None,
requires_action_by=REQUIRES_ACTION_BY.OPERATOR)
obj4 = make_recipe('legalaid.case',
reference='ref4',
provider=None,
requires_action_by=REQUIRES_ACTION_BY.OPERATOR,
requires_action_at=now +
datetime.timedelta(seconds=2))
obj5 = make_recipe('legalaid.case',
reference='ref5',
provider=None,
requires_action_by=REQUIRES_ACTION_BY.OPERATOR,
requires_action_at=now -
datetime.timedelta(seconds=1))
# searching via dashboard param => should return obj3, obj4, obj5
response = self.client.get(self.list_dashboard_url,
format='json',
HTTP_AUTHORIZATION='Bearer %s' % self.token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(2, len(response.data['results']))
self.assertItemsEqual(
[case['reference'] for case in response.data['results']],
['ref3', 'ref5'])
# searching without dashboard param => should return all of them
response = self.client.get(self.list_url,
format='json',
HTTP_AUTHORIZATION='Bearer %s' % self.token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(5, len(response.data['results']))
self.assertItemsEqual(
[case['reference'] for case in response.data['results']],
['ref1', 'ref2', 'ref3', 'ref4', 'ref5'])
def setUp(self):
graph_inscope_context = self.mocked_graph.node["INSCOPE"]["context"]
self.category = make_recipe("legalaid.Category", code=graph_inscope_context["category"])
self.matter_type1 = make_recipe(
"legalaid.matter_type1", code=graph_inscope_context["matter-type-1"], category=self.category
)
self.matter_type2 = make_recipe(
"legalaid.matter_type2", code=graph_inscope_context["matter-type-2"], category=self.category
)
def test_delete_objects(self):
make_recipe("legalaid.case")
cases = Case.objects.all()
self.assertEqual(len(cases), 1)
self.delete_old_data._delete_objects(cases)
self.assertEqual(len(Case.objects.all()), 0)
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 test_cleanup_case_audit(self):
log = make_recipe("cla_auditlog.audit_log")
make_recipe("legalaid.case", audit_log=[log])
pks = get_pks(Case.objects.all())
self.assertEqual(len(AuditLog.objects.filter(case__in=pks)), 1)
self.delete_old_data.cleanup_audit(pks)
self.assertEqual(len(AuditLog.objects.filter(case__in=pks)), 0)
def test_operator_with_organisation(self):
organisation = make_recipe("call_centre.organisation",
name="Test organisation")
operator = make_recipe("call_centre.operator",
is_cla_superuser=False,
is_manager=False,
organisation=organisation)
self.assertEqual(operator.organisation.name, "Test organisation")
self.assertEqual(operator.organisation.id, organisation.id)
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_cleanup_personal_details_no_case_attached_successful(self):
contact_method = make_recipe("legalaid.contact_research_method")
make_recipe("legalaid.personal_details",
contact_for_research_methods=[contact_method])
self.assertEqual(len(PersonalDetails.objects.all()), 1)
self.delete_old_data.cleanup_personal_details()
self.assertEqual(len(PersonalDetails.objects.all()), 0)
def setUp(self):
self.category = make_recipe("legalaid.category")
self.helper = ProviderAllocationHelper()
self.date = timezone.now().replace(hour=0, minute=0, second=0)
self.provider_allocations = make_recipe(
"cla_provider.provider_allocation",
category=self.category,
weighted_distribution=1.0,
provider__active=True,
_quantity=10,
)
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 get_default_post_data(self):
category = make_recipe('legalaid.category')
matter_type1 = make_recipe('legalaid.matter_type1', category=category)
matter_type2 = make_recipe('legalaid.matter_type2', category=category)
return {
'category': category.code,
'matter_type1': matter_type1.code,
'matter_type2': matter_type2.code,
'notes': 'Notes',
'internal': False
}
def test_CBC(self):
# with callback_attempt == 1
case = make_recipe("legalaid.case", callback_attempt=1)
self._test_process_with_implicit_code("CBC", dummy_case=case, process_kwargs={"cancel": True})
# with callback_attempt == 2
case = make_recipe("legalaid.case", callback_attempt=2)
self._test_process_with_implicit_code("CBC", dummy_case=case, process_kwargs={"cancel": True})
# with callback_attempt == 3
case = make_recipe("legalaid.case", callback_attempt=3)
self._test_process_with_implicit_code("CBC", dummy_case=case, process_kwargs={"cancel": True})
def test_list_with_person_ref_param(self):
"""
Testing that if ?person_ref param is specified, it will only return
cases for that person
"""
Case.objects.all().delete()
pd1 = make_recipe("legalaid.personal_details")
pd2 = make_recipe("legalaid.personal_details")
make_recipe("legalaid.case", reference="ref1", personal_details=pd1)
make_recipe("legalaid.case", reference="ref2", personal_details=pd2)
make_recipe("legalaid.case", reference="ref3", personal_details=pd1)
# searching for pd1
response = self.client.get(
self.get_list_person_ref_url(pd1.reference),
format="json",
HTTP_AUTHORIZATION=self.get_http_authorization(),
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(2, len(response.data["results"]))
self.assertItemsEqual([c["reference"] for c in response.data["results"]], ["ref1", "ref3"])
# searching for pd2 AND dashboard=1 should ignore dashboard param
url = "%s&dashboard=1" % self.get_list_person_ref_url(pd2.reference)
response = self.client.get(url, format="json", HTTP_AUTHORIZATION=self.get_http_authorization())
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(1, len(response.data["results"]))
self.assertItemsEqual([case["reference"] for case in response.data["results"]], ["ref2"])
def test_stop_success(self):
timer = make_recipe("timer.Timer", stopped=None)
case = make_recipe("legalaid.Case")
make_recipe("cla_eventlog.Log", timer=timer, case=case)
self.assertEqual(timer.stopped, None)
self.assertEqual(timer.linked_case, None)
timer.stop()
timer = Timer.objects.get(pk=timer.pk) # reloading
self.assertNotEqual(timer.stopped, None)
self.assertEqual(timer.linked_case, case)
def test_get_object(self):
"""
GET should not return properties of other eligibility check objects
"""
make_recipe("legalaid.property", eligibility_check=self.resource, _quantity=4)
# making extra properties
make_recipe("legalaid.property", eligibility_check=self.resource, _quantity=5)
self.assertEqual(Property.objects.count(), 9)
response = self.client.get(self.detail_url, format="json", HTTP_AUTHORIZATION=self.get_http_authorization())
self.assertResponseKeys(response)
self.assertEligibilityCheckEqual(response.data, self.resource)
def get_default_post_data(self):
category = make_recipe('legalaid.category')
matter_type1 = make_recipe(
'legalaid.matter_type1', category=category
)
matter_type2 = make_recipe(
'legalaid.matter_type2', category=category
)
return {
'category': category.code,
'matter_type1': matter_type1.code,
'matter_type2': matter_type2.code,
'notes': 'Notes',
'internal': False
}
def test_get_not_found_if_belonging_to_different_provider(self):
other_provider = make_recipe('cla_provider.provider')
check = make_recipe('legalaid.eligibility_check')
check_case = make_recipe(
'legalaid.case', eligibility_check=check,
provider=other_provider, requires_action_by=REQUIRES_ACTION_BY.PROVIDER
)
detail_url = self.get_detail_url(check_case.reference)
response = self.client.get(
detail_url, format='json',
HTTP_AUTHORIZATION=self.get_http_authorization()
)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_save_successfull(self):
case = make_recipe('legalaid.case')
self.assertEqual(case.provider_closed, None)
self._test_save_successfull(case=case)
self.assertNotEqual(case.provider_closed, None)
def test_case_serializer_with_eligibility_check_reference(self):
eligibility_check = make_recipe("legalaid.eligibility_check")
data = {u"eligibility_check": eligibility_check.reference}
serializer = CaseSerializer(data=data)
self.assertTrue(serializer.is_valid())
self.assertDictEqual(serializer.errors, {})
def test_case_serializer_with_media_code(self):
media_code = make_recipe("legalaid.media_code")
data = {u"media_code": media_code.code}
serializer = CaseSerializer(data=data)
self.assertTrue(serializer.is_valid())
self.assertDictEqual(serializer.errors, {})
