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(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_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_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)
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(BaseEventTestCase, self).setUp() self.dummy_case = make_recipe("legalaid.case") self.dummy_user = make_user()