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, {})