def test_get_filters_multiple_sites(self): """If more than one site exists, there should be a noneornull filter for Other sites""" site = qa_utils.create_site() qa_utils.create_unit(name="second unit", site=site) utils.create_fault() filters = views.FaultList().get_filters('unit__site__name') assert filters == [('noneornull', 'Other')]
def test_to_table_reviewed(self): site = USite.objects.create(name="site") unit1 = utils.create_unit(site=site) fault_utils.create_fault(unit=unit1) unit2 = utils.create_unit() fault2 = fault_utils.create_fault(unit=unit2) fault_rev = fault_utils.create_fault_review(fault=fault2) comment = Comment(submit_date=timezone.now(), user=fault_rev.reviewed_by, content_object=fault_rev.fault, comment="comment", site=get_current_site(None)) comment.save() rep = faults.FaultSummaryReport( report_opts={'review_status': "reviewed"}) rep.report_format = "csv" context = rep.get_context() table = rep.to_table(context) header_row = table.index([ _("Fault ID"), _("Occurred"), _("Site"), _("Unit"), _("Fault Type"), _("Modality"), _("Link"), ]) # should be one fault after header assert len(table[header_row + 1:]) == 1
def test_load_result_set(self): """Calling via ajax should return a single object in the queryset""" utils.create_fault() resp = self.client.get(self.url, {}, content_type='application/json', HTTP_X_REQUESTED_WITH='XMLHttpRequest') assert len(resp.json()['aaData']) == 1
def test_send_notice_no_recipients(self): utils.create_fault() self.recipients.groups.clear() tasks.send_faultsreview_notice(self.notice.pk) self.notice.refresh_from_db() assert self.notice.last_sent is None assert len(mail.outbox) == 0
def test_get_qs(self): site = AdminSite() adm = admin.FaultAdmin(Fault, site) ft1 = utils.create_fault_type() ft2 = utils.create_fault_type() utils.create_fault(fault_type=[ft1, ft2]) assert adm.get_queryset(None).count() == 1
def setUp(self): self.unit1 = qa_utils.create_unit(name="unit1", number=1) self.unit2 = qa_utils.create_unit(name="unit2", number=2) self.fault1 = utils.create_fault(unit=self.unit1) self.fault2 = utils.create_fault(unit=self.unit2) self.unit_group = UnitGroup.objects.create(name="test group") self.unit_group.units.add(self.unit1) self.group = qa_utils.create_group() self.user = models.User.objects.latest('pk') self.user.is_active = True self.user.groups.add(self.group) self.user.email = "*****@*****.**" self.user.save() self.recipients = RecipientGroup.objects.create(name="test group") self.recipients.groups.add(self.group) self.inactive_user = models.User.objects.create_user('inactive', '*****@*****.**', 'password') self.inactive_user.groups.add(self.group) self.inactive_user.is_active = False self.inactive_user.save() # delete defaults schedules to make counting easier Schedule.objects.all().delete()
def test_email_sent_to_group_for_unit(self): """An email should not be sent when when a fault is created for a unit belonging to a unit group""" FaultNotice.objects.create( notification_type=FaultNotice.LOGGED, recipients=self.recipients, units=self.unit_group, ) utils.create_fault(unit=self.unit) self.assertEqual(len(mail.outbox), 1)
def test_email_sent(self): """An email should be sent when a fault is created""" notification = FaultNotice.objects.create( notification_type=FaultNotice.LOGGED, recipients=self.recipients, ) notification.save() utils.create_fault() self.assertEqual(len(mail.outbox), 1)
def test_unreviewed_filter(self): site = USite.objects.create(name="site") unit1 = utils.create_unit(site=site) fault_utils.create_fault(unit=unit1) rep = faults.FaultSummaryReport( report_opts={'review_status': "unreviewed"}) rep.report_format = "csv" context = rep.get_context() assert len(context['sites_data'][0][1]) == 1
def test_no_filter(self): """If there is no modality filter, all faults should be returned""" utils.create_fault(unit=self.unit, user=self.user, fault_type=self.fault_type) utils.create_fault(unit=self.unit, user=self.user, fault_type=self.fault_type) with mock.patch.object(self.mf, "value", return_value=None): qs = self.mf.queryset(None, Fault.objects.all()) assert list(qs) == list(Fault.objects.all())
def test_load_result_set(self): """Calling via ajax should return a single object in the queryset""" fault1 = utils.create_fault() u2 = qa_utils.create_unit() utils.create_fault(unit=u2) url = reverse("fault_list_by_unit", kwargs={'unit_number': fault1.unit.number}) resp = self.client.get(url, {}, content_type='application/json', HTTP_X_REQUESTED_WITH='XMLHttpRequest') assert len(resp.json()['aaData']) == 1
def test_email_not_sent_to_group_for_excluded_unit(self): """Fault is created on 2nd unit so no one should get an email""" FaultNotice.objects.create( notification_type=FaultNotice.LOGGED, recipients=self.recipients, units=self.unit_group, ) utils.create_fault(unit=None) self.assertEqual(len(mail.outbox), 0)
def test_get_faults_for_null_site(self): site = USite.objects.create(name="site") unit1 = utils.create_unit(site=site) fault_utils.create_fault(unit=unit1) unit2 = utils.create_unit(site=None) fault2 = fault_utils.create_fault(unit=unit2) qs = models.Fault.objects.all() fs = faults.FaultSummaryReport().get_faults_for_site(qs, None) assert [x.pk for x in fs] == [fault2.pk]
def test_generate_html(self): site = USite.objects.create(name="site") unit1 = utils.create_unit(site=site) fault_utils.create_fault(unit=unit1) unit2 = utils.create_unit() fault_utils.create_fault(unit=unit2) rep = faults.FaultSummaryReport() rep.report_format = "pdf" rep.to_html()
def test_load_result_set(self): """Calling via ajax should return a single object in the queryset""" fault1 = utils.create_fault() ft = FaultType.objects.create(code="new ft") utils.create_fault(fault_type=ft) kwargs = { 'unit_number': fault1.unit.number, 'slug': fault1.fault_types.first().slug } url = reverse("fault_list_by_unit_type", kwargs=kwargs) resp = self.client.get(url, {}, content_type='application/json', HTTP_X_REQUESTED_WITH='XMLHttpRequest') assert len(resp.json()['aaData']) == 1
def test_filter(self): """If user filters by modality, only faults with that modality should be returned""" f = utils.create_fault(unit=self.unit, user=self.user, fault_type=self.fault_type) correct_modality = utils.create_fault(unit=self.unit, user=self.user, fault_type=f.fault_types.first(), modality=self.modality) with mock.patch.object(self.mf, "value", return_value=self.modality.id): qs = self.mf.queryset(None, Fault.objects.all()) assert list(qs) == [correct_modality]
def test_edit_with_invalid_reviews(self): """Test that editing a fault and adding a reviewer works""" FaultType.objects.create(code="fault type") fault = utils.create_fault(user=self.user) rev_group = utils.create_fault_review_group() self.user.groups.add(rev_group.group) assert fault.modality is None modality = u_models.Modality.objects.create(name="modality") fault.unit.modalities.add(modality) edit_url = reverse("fault_edit", kwargs={'pk': fault.pk}) se = sl_utils.create_service_event() fault.related_service_events.add(se) data = { "fault-occurred": format_datetime(fault.occurred), "fault-unit": fault.unit.id, "fault-modality": modality.pk, "fault-fault_types_field": [fault.fault_types.first().code], "fault-comment": "", "fault-related_service_events": [se.pk], "review-form-0-group": rev_group.group.name, "review-form-0-reviewed_by": "", } assert fault.faultreviewinstance_set.count() == 0 resp = self.client.post(edit_url, data) assert resp.status_code == 200 assert resp.context['review_forms'][0].errors['reviewed_by']
def test_load_page(self): """Initial page load should work ok""" fault = utils.create_fault(fault_type=self.fault_type) url = reverse("fault_type_details", kwargs={'slug': fault.fault_types.first().slug}) resp = self.client.get(url, {}) assert resp.status_code == 200
def test_send_notice(self): self.faults1 = utils.create_fault() now = timezone.now() tasks.send_faultsreview_notice(self.notice.pk) self.notice.refresh_from_db() assert self.notice.last_sent >= now assert "QATrack+ Unreviewed Faults Notice:" in mail.outbox[0].subject
def test_valid_edit_remove_ft(self): """Test that editing a fault and modifying a field works""" FaultType.objects.create(code="fault type") ft1 = utils.create_fault_type() ft2 = utils.create_fault_type() fault = utils.create_fault(fault_type=[ft1, ft2]) assert fault.modality is None modality = u_models.Modality.objects.create(name="modality") fault.unit.modalities.add(modality) edit_url = reverse("fault_edit", kwargs={'pk': fault.pk}) se = sl_utils.create_service_event() fault.related_service_events.add(se) data = { "fault-occurred": format_datetime(fault.occurred), "fault-unit": fault.unit.id, "fault-modality": modality.pk, "fault-fault_types_field": [ft2.code], "fault-comment": "", "fault-related_service_events": [se.pk], } assert fault.fault_types.count() == 2 resp = self.client.post(edit_url, data) assert resp.status_code == 302 fault.refresh_from_db() assert fault.modality == modality assert fault.fault_types.count() == 1 assert resp.url == self.list_url
def test_invalid_edit(self): """Test that editing a fault and modifying a field works""" modality = u_models.Modality.objects.create(name="modality") FaultType.objects.create(code="fault type") fault = utils.create_fault() assert fault.modality is None edit_url = reverse("fault_edit", kwargs={'pk': fault.pk}) se = sl_utils.create_service_event() fault.related_service_events.add(se) data = { "fault-occurred": format_datetime(fault.occurred), "fault-unit": '', "fault-modality": modality.pk, "fault-fault_types_field": [fault.fault_types.first().code], "fault-comment": "", "fault-related_service_events": [se.pk], } resp = self.client.post(edit_url, data) assert resp.status_code == 200
def test_to_table(self): site = USite.objects.create(name="site") unit1 = utils.create_unit(site=site) fault_utils.create_fault(unit=unit1) unit2 = utils.create_unit() fault2 = fault_utils.create_fault(unit=unit2) usa2 = sl_utils.create_unit_service_area(unit=unit2) sl_utils.create_service_event(unit_service_area=usa2) se2 = sl_utils.create_service_event(unit_service_area=usa2) fault2.related_service_events.add(se2) user = sl_utils.create_user() comment = Comment(submit_date=timezone.now(), user=user, content_object=fault2, comment="comment", site=get_current_site(None)) comment.save() rep = faults.FaultDetailsReport( report_opts={'review_status': 'unreviewed'}) rep.report_format = "csv" context = rep.get_context() table = rep.to_table(context) header_row = table.index([ _("Fault ID"), _("Occurred"), _("Site"), _("Unit"), _("Fault Type"), _("Modality"), _("Created By"), _("Created Date"), _("Modified By"), _("Modified Date"), _("Reviewed By"), _("Reviewed Date"), _("Related Service Events"), _("Link"), ]) # should be three faults after header assert len(table[header_row + 1:]) == 2
def test_unreviewed(self): """Two Faults created, only the unreviewed should be returned by the unreviewed manager""" utils.create_fault_review() unreviewed = utils.create_fault() assert Fault.objects.unreviewed().count() == 1 assert Fault.objects.unreviewed().all()[0].pk == unreviewed.pk
def test_review_bulk(self): group = qa_utils.create_group("group") self.user.groups.add(group) frg = FaultReviewGroup.objects.create(group=group) f1 = utils.create_fault() f2 = utils.create_fault() review_url = reverse("fault_bulk_review") data = {'faults': [f1.pk, f2.pk]} resp = self.client.post(review_url, data=data) assert resp.status_code == 200 assert resp.json()['ok'] f1.refresh_from_db() f2.refresh_from_db() assert f1.faultreviewinstance_set.count() > 0 assert f1.faultreviewinstance_set.first().fault_review_group == frg assert f2.faultreviewinstance_set.count() > 0
def test_load_page(self): """Initial page load should work ok""" fault_type = FaultType.objects.create(code="ABC", slug="abc") fault = utils.create_fault(fault_type=fault_type) url = reverse("fault_details", kwargs={'pk': fault.pk}) resp = self.client.get(url) assert resp.status_code == 200 assert resp.context['fault'].id == fault.id
def test_email_sent_to_group_and_single_user(self): """Main group is not included in notification, only new user, so only one email should be sent to the new user""" FaultNotice.objects.create( notification_type=FaultNotice.LOGGED, recipients=self.recipients, ) user2 = create_user(uname="user2") user2.email = "*****@*****.**" user2.save() self.recipients.users.add(user2) utils.create_fault(unit=self.unit) assert len(mail.outbox) == 1 assert list(sorted(mail.outbox[0].recipients())) == [ '*****@*****.**', '*****@*****.**' ]
def test_get_fault_types(self): ft1 = utils.create_fault_type() ft2 = utils.create_fault_type() fault = utils.create_fault(fault_type=[ft1, ft2]) site = AdminSite() adm = admin.FaultAdmin(Fault, site) qs = fault.fault_types.order_by("code").values_list("code", flat=True) assert adm.get_fault_types(fault) == ', '.join(qs)
def test_load_result_set(self): """Calling via ajax should return a single object in the queryset""" fault = utils.create_fault(fault_type=self.fault_type) url = reverse("fault_type_details", kwargs={'slug': fault.fault_types.first().slug}) resp = self.client.get(url, {}, content_type='application/json', HTTP_X_REQUESTED_WITH='XMLHttpRequest') assert len(resp.json()['aaData']) == 1
def test_email_not_sent_on_edit(self): """An email should not be sent when a fault is edited""" fault = utils.create_fault() FaultNotice.objects.create( notification_type=FaultNotice.LOGGED, recipients=self.recipients, ) fault.save() self.assertEqual(len(mail.outbox), 0)
def test_email_not_sent_to_group_for_unit(self): """Main group is not included in notification, only the new group, so only one email should be sent to the new user""" group2 = qa_utils.create_group(name="group2") rg = RecipientGroup.objects.create(name='group2') rg.groups.add(group2) FaultNotice.objects.create( notification_type=FaultNotice.LOGGED, recipients=rg, units=self.unit_group, ) user2 = create_user(uname="user2") user2.email = "*****@*****.**" user2.save() user2.groups.add(group2) utils.create_fault(unit=self.unit) assert len(mail.outbox) == 1 assert mail.outbox[0].recipients() == ['*****@*****.**']