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() == ['*****@*****.**']
