def test_to_table(self):
site = USite.objects.create(name="site")
unit1 = utils.create_unit(site=site)
usa1 = sl_utils.create_unit_service_area(unit=unit1)
sl_utils.create_service_event(unit_service_area=usa1)
unit2 = utils.create_unit()
usa2 = sl_utils.create_unit_service_area(unit=unit2)
sl_utils.create_service_event(unit_service_area=usa2)
rep = sl.ServiceEventSummaryReport(report_opts={'include_description': True})
rep.report_format = "csv"
context = rep.get_context()
table = rep.to_table(context)
header_row = table.index([
_("Service Event ID"),
_("Service Date"),
_("Site"),
_("Unit"),
_("Service Area"),
_("Service Type"),
_("Status"),
_("Service Time"),
_("Lost Time"),
_("Problem Description"),
_("Work Description"),
_("Link"),
])
# should be two ses after header
assert len(table[header_row + 1:]) == 2
def test_send_notice_no_recipients(self):
utils.create_service_event(is_review_required=True)
self.recipients.groups.clear()
tasks.send_serviceeventreview_notice(self.notice.pk)
self.notice.refresh_from_db()
assert self.notice.last_sent is None
assert len(mail.outbox) == 0
def test_to_table(self):
site = USite.objects.create(name="site")
unit1 = utils.create_unit(site=site)
usa1 = sl_utils.create_unit_service_area(unit=unit1)
sl_utils.create_service_event(unit_service_area=usa1)
unit2 = utils.create_unit()
usa2 = sl_utils.create_unit_service_area(unit=unit2)
se = sl_utils.create_service_event(unit_service_area=usa2)
se2 = sl_utils.create_service_event(unit_service_area=usa2)
se.service_event_related.add(se2)
sl_utils.create_hours(service_event=se)
tp = sl_utils.create_third_party()
sl_utils.create_hours(service_event=se, third_party=tp)
sl_utils.create_group_linker_instance(service_event=se)
part = sl_utils.create_part()
parts_models.PartUsed.objects.create(service_event=se, part=part, quantity=1)
attachment = Attachment(
attachment=ContentFile("content", "content.pdf"),
created_by=se.user_created_by,
serviceevent=se,
)
attachment.save()
rep = sl.ServiceEventPersonnelSummaryReport()
rep.report_format = "xlsx"
context = rep.get_context()
rep.to_table(context)
def setUp(self):
self.unit1 = qa_utils.create_unit(name="unit1", number=1)
self.unit2 = qa_utils.create_unit(name="unit2", number=2)
self.usa1 = utils.create_unit_service_area(unit=self.unit1)
self.usa2 = utils.create_unit_service_area(unit=self.unit2)
self.se1 = utils.create_service_event(unit_service_area=self.usa1,
is_review_required=True)
self.se2 = utils.create_service_event(unit_service_area=self.usa2,
is_review_required=False)
self.unit_group = UnitGroup.objects.create(name="test group")
self.unit_group.units.add(self.usa1.unit)
self.group = qa_utils.create_group()
user = models.User.objects.latest('pk')
user.is_active = True
user.groups.add(self.group)
user.email = "*****@*****.**"
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_get_ses_for_null_site(self):
site = USite.objects.create(name="site")
unit1 = utils.create_unit(site=site)
usa1 = sl_utils.create_unit_service_area(unit=unit1)
sl_utils.create_service_event(unit_service_area=usa1)
unit2 = utils.create_unit(site=None)
usa2 = sl_utils.create_unit_service_area(unit=unit2)
se2 = sl_utils.create_service_event(unit_service_area=usa2)
qs = models.ServiceEvent.objects.all()
ses = sl.ServiceEventSummaryReport().get_ses_for_site(qs, None)
assert [x.pk for x in ses] == [se2.pk]
def test_generate_html(self):
site = USite.objects.create(name="site")
unit1 = utils.create_unit(site=site)
usa1 = sl_utils.create_unit_service_area(unit=unit1)
sl_utils.create_service_event(unit_service_area=usa1)
unit2 = utils.create_unit()
usa2 = sl_utils.create_unit_service_area(unit=unit2)
sl_utils.create_service_event(unit_service_area=usa2)
rep = sl.ServiceEventSummaryReport()
rep.report_format = "pdf"
rep.to_html()
def test_valid_create_with_invalid_review(self):
"""Test that creating a fault with all options and an invalid reviewer does not work"""
ft = FaultType.objects.create(code="fault type")
rev_group = utils.create_fault_review_group()
self.user.groups.add(rev_group.group)
usa = sl_utils.create_unit_service_area(unit=self.unit)
se = sl_utils.create_service_event(unit_service_area=usa)
data = {
"fault-occurred": "20 Jan 2021 17:59",
"fault-unit": self.unit.id,
"fault-modality": self.unit.modalities.all().first().pk,
"fault-fault_types_field": [ft.code],
"fault-comment": "test comment",
"fault-related_service_events": [se.pk],
"review-form-0-group": rev_group.group.name,
"review-form-0-reviewed_by": "",
}
resp = self.client.post(self.create_url, data)
assert resp.status_code == 200
assert resp.context['review_forms'][0].errors
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_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_valid_create_with_review(self):
"""Test that creating a fault with all options and a reviewer set works"""
ft = FaultType.objects.create(code="fault type")
rev_group = utils.create_fault_review_group()
self.user.groups.add(rev_group.group)
usa = sl_utils.create_unit_service_area(unit=self.unit)
se = sl_utils.create_service_event(unit_service_area=usa)
data = {
"fault-occurred": "20 Jan 2021 17:59",
"fault-unit": self.unit.id,
"fault-modality": self.unit.modalities.all().first().pk,
"fault-fault_types_field": [ft.code],
"fault-comment": "test comment",
"fault-related_service_events": [se.pk],
"review-form-0-group": rev_group.group.name,
"review-form-0-reviewed_by": self.user.pk,
}
resp = self.client.post(self.create_url, data)
assert resp.status_code == 302
assert resp.url == self.list_url
assert Comment.objects.count() == 1
f = Fault.objects.latest('pk')
assert f.faultreviewinstance_set.count() == 1
assert list(f.related_service_events.values_list(
"id", flat=True)) == [se.id]
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_created(self):
se = sl_utils.create_service_event()
models.ServiceLog.objects.create(
user=self.user,
log_type=models.NEW_SERVICE_EVENT,
service_event=se,
)
assert len(mail.outbox) == 1
assert "Service Event %s" % se in mail.outbox[0].subject
def create_objects(self):
se_requires_review = sl_utils.create_service_event(
is_review_required=True)
ses_default = sl_utils.create_service_event_status(is_default=True)
se_default_status = sl_utils.create_service_event(
service_status=ses_default)
sl_utils.create_return_to_service_qa(
add_test_list_instance=True) # qa_not_reviewed +1
sl_utils.create_return_to_service_qa() # qa_not_complete +1
sl_utils.create_return_to_service_qa(
service_event=se_requires_review
) # se_needing_review +1, qa_not_complete +1
sl_utils.create_return_to_service_qa(
service_event=se_default_status
) # se_default +1, qa_not_complete +1
self.user = create_user(is_superuser=True, uname='person')
def test_generate_html(self):
site = USite.objects.create(name="site")
unit1 = utils.create_unit(site=site)
usa1 = sl_utils.create_unit_service_area(unit=unit1)
sl_utils.create_service_event(
unit_service_area=usa1,
service_time=timezone.timedelta(hours=1, minutes=23),
lost_time=timezone.timedelta(hours=1, minutes=23),
)
unit2 = utils.create_unit()
usa2 = sl_utils.create_unit_service_area(unit=unit2)
sl_utils.create_service_event(unit_service_area=usa2)
rep = sl.ServiceTimesReport()
rep.report_format = "pdf"
rep.to_html()
def test_to_table(self):
site = USite.objects.create(name="site")
unit1 = utils.create_unit(site=site)
usa1 = sl_utils.create_unit_service_area(unit=unit1)
sl_utils.create_service_event(
unit_service_area=usa1,
service_time=timezone.timedelta(hours=1, minutes=23),
lost_time=timezone.timedelta(hours=1, minutes=23),
)
unit2 = utils.create_unit()
usa2 = sl_utils.create_unit_service_area(unit=unit2)
sl_utils.create_service_event(unit_service_area=usa2)
rep = sl.ServiceTimesReport()
rep.report_format = "xlsx"
context = rep.get_context()
rep.to_table(context)
def test_created_no_recipients(self):
self.recipients.groups.clear()
se = sl_utils.create_service_event()
models.ServiceLog.objects.create(
user=self.user,
log_type=models.NEW_SERVICE_EVENT,
service_event=se,
)
assert len(mail.outbox) == 0
def test_send_notice(self):
self.se1 = utils.create_service_event(unit_service_area=self.usa1)
self.se1.is_review_required = True
self.se1.save()
now = timezone.now()
tasks.send_serviceeventreview_notice(self.notice.pk)
self.notice.refresh_from_db()
assert self.notice.last_sent >= now
assert "QATrack+ Unreviewed Service Event Notice:" in mail.outbox[
0].subject
def test_valid_delete(self):
"""Test that deleting a fault works"""
fault = utils.create_fault()
delete_url = reverse("fault_delete", kwargs={'pk': fault.pk})
se = sl_utils.create_service_event()
fault.related_service_events.add(se)
resp = self.client.post(delete_url)
assert resp.status_code == 302
assert resp.url == '/faults/'
assert Fault.objects.count() == 0
def test_qa_urls(self):
sl_utils.create_service_event_status(is_default=True)
qa_utils.create_status(is_default=True)
se = sl_utils.create_service_event()
u = qa_utils.create_unit()
utc = qa_utils.create_unit_test_collection(unit=u)
tli = qa_utils.create_test_list_instance(unit_test_collection=utc)
url_names_200 = (
('sl_dash', {}, ''),
('sl_new', {}, ''),
('sl_edit', {
'pk': se.id
}, ''),
('sl_details', {
'pk': se.id
}, ''),
('sl_list_all', {}, ''),
('rtsqa_list_for_event', {
'se_pk': se.id
}, ''),
('se_searcher', {}, '?q=%d&unit_id=%d' % (se.id, u.id)),
('tli_select', {
'pk': utc.id,
'form': 'a_form'
}, ''),
('tli_statuses', {}, '?tli_id=%d' % tli.id),
('unit_sa_utc', {}, '?unit_id=%d' % u.id),
('err', {}, ''),
('sl_unit_new', {}, ''),
('sl_unit_view_se', {}, ''),
('se_down_time', {}, ''),
('handle_unit_down_time', {}, ''),
)
url_names_404 = (
# Test urls that expect kwargs when not given any
# (reverse should render url for use in templates, but return 404)
('sl_details', {}, ''),
('tli_select', {}, ''),
('se_searcher', {}, ''),
('tli_statuses', {}, ''),
('unit_sa_utc', {}, ''),
)
for url, kwargs, q in url_names_200:
self.assertTrue(self.returns_code(reverse(url, kwargs=kwargs) + q))
for url, kwargs, q in url_names_404:
self.assertTrue(
self.returns_code(reverse(url, kwargs=kwargs) + q, code=404))
def test_valid_edit_load(self):
"""Test that editing a fault and modifying a field works"""
FaultType.objects.create(code="fault type")
fault = utils.create_fault()
edit_url = reverse("fault_edit", kwargs={'pk': fault.pk})
se = sl_utils.create_service_event()
fault.related_service_events.add(se)
resp = self.client.get(edit_url)
assert resp.status_code == 200
def test_delete_serviceevent_variables(self):
# unit_service_area > Protect
# service_type > Protect
# service_status > Protect
# user_status_changed_by > Protect
# user_created_by > Protect
# user_modified_by > Protect
# test_list_instance_initiated_by > Set Null
sl_utils.create_service_event_status(is_default=True)
ses = sl_utils.create_service_event_status()
se = sl_utils.create_service_event(
add_test_list_instance_initiated_by=True, service_status=ses)
se.user_status_changed_by = create_user()
se.user_modified_by = create_user()
se.save()
se_id = se.id
usa = se.unit_service_area
st = se.service_type
u_scb = se.user_status_changed_by
u_cb = se.user_created_by
u_mb = se.user_modified_by
tli = se.test_list_instance_initiated_by
with self.assertRaises(ProtectedError):
usa.delete()
with self.assertRaises(ProtectedError):
st.delete()
with self.assertRaises(ProtectedError):
ses.delete()
with self.assertRaises(ProtectedError):
u_scb.delete()
with self.assertRaises(ProtectedError):
u_cb.delete()
with self.assertRaises(ProtectedError):
u_mb.delete()
tli.delete()
se = sl_models.ServiceEvent.objects.get(id=se_id)
self.assertEqual(None, se.test_list_instance_initiated_by)
def test_edit_with_changed_reviews(self):
"""Test that editing a fault with existing reviewer works"""
FaultType.objects.create(code="fault type")
fault = utils.create_fault(user=self.user)
rev_group = utils.create_fault_review_group()
utils.create_fault_review(fault=fault,
review_group=rev_group,
reviewed_by=self.user)
self.user.groups.add(rev_group.group)
new_u = qa_utils.create_user()
new_u.groups.add(rev_group.group)
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": new_u.pk,
}
assert list(
fault.faultreviewinstance_set.values_list(
"reviewed_by_id", flat=True)) == [self.user.pk]
resp = self.client.post(edit_url, data)
assert resp.status_code == 302
fault.refresh_from_db()
assert fault.faultreviewinstance_set.count() == 1
assert list(
fault.faultreviewinstance_set.values_list(
"reviewed_by_id", flat=True)) == [new_u.pk]
def setUp(self):
self.user = create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
self.tli = qa_utils.create_test_list_instance()
self.usa = sl_utils.create_unit_service_area(unit=self.tli.unit_test_collection.unit)
self.se = sl_utils.create_service_event(
unit_service_area=self.usa,
add_test_list_instance_initiated_by=self.tli,
)
sl_utils.create_return_to_service_qa(add_test_list_instance=self.tli)
self.url_list = reverse(
'admin:%s_%s_changelist' % (
qa_models.TestListInstance._meta.app_label, qa_models.TestListInstance._meta.model_name
)
)
self.url_delete = reverse(
'admin:%s_%s_delete' % (
qa_models.TestListInstance._meta.app_label, qa_models.TestListInstance._meta.model_name
),
args=[self.tli.id]
)
def test_valid_create(self):
"""Test that creating a fault with all options set works"""
ft = FaultType.objects.create(code="fault type")
usa = sl_utils.create_unit_service_area(unit=self.unit)
se = sl_utils.create_service_event(unit_service_area=usa)
data = {
"fault-occurred": "20 Jan 2021 17:59",
"fault-unit": self.unit.id,
"fault-modality": self.unit.modalities.all().first().pk,
"fault-fault_types_field": [ft.code],
"fault-comment": "test comment",
"fault-related_service_events": [se.pk],
}
resp = self.client.post(self.create_url, data)
assert resp.status_code == 302
assert resp.url == self.list_url
assert Comment.objects.count() == 1
assert list(
Fault.objects.latest('pk').related_service_events.values_list(
"id", flat=True)) == [se.id]
def test_valid_create_attach(self):
"""Test that creating a fault with all options set works"""
ft = FaultType.objects.create(code="fault type")
usa = sl_utils.create_unit_service_area(unit=self.unit)
se = sl_utils.create_service_event(unit_service_area=usa)
test_file = SimpleUploadedFile("TESTRUNNER_test_file.json", b"{}")
data = {
"fault-occurred": "20 Jan 2021 17:59",
"fault-unit": self.unit.id,
"fault-modality": self.unit.modalities.all().first().pk,
"fault-fault_types_field": [ft.code],
"fault-comment": "test comment",
"fault-related_service_events": [se.pk],
"fault-attachments": [test_file],
}
resp = self.client.post(self.create_url, data)
assert resp.status_code == 302
assert resp.url == self.list_url
assert Attachment.objects.count() == 1
assert Attachment.objects.get(fault=Fault.objects.latest("pk"))
def test_valid_edit_remove_attach(self):
"""Test that editing a fault and modifying a field works"""
FaultType.objects.create(code="fault type")
fault = utils.create_fault()
test_file = SimpleUploadedFile("TESTRUNNER_test_file.json", b"{}")
attach = Attachment.objects.create(fault=fault,
attachment=test_file,
created_by=self.user)
assert fault.attachment_set.count() == 1
ft2 = utils.create_fault_type()
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, ft2.code],
"fault-comment": "",
"fault-related_service_events": [se.pk],
"fault-attachments_delete_ids": [attach.id, ''],
}
resp = self.client.post(edit_url, data)
assert resp.status_code == 302
fault.refresh_from_db()
assert fault.attachment_set.count() == 0
def setUp(self):
self.se = sl_utils.create_service_event()
def setUp(self):
self.factory = RequestFactory()
self.user = create_user(is_superuser=True)
self.client.login(username='******', password='******')
self.u1 = qa_utils.create_unit()
self.u2 = qa_utils.create_unit()
self.u3 = qa_utils.create_unit()
self.usa1 = sl_utils.create_unit_service_area(unit=self.u1)
self.usa2 = sl_utils.create_unit_service_area(unit=self.u2)
self.usa2 = sl_utils.create_unit_service_area(unit=self.u2)
self.usa3 = sl_utils.create_unit_service_area(unit=self.u3)
self.usa3 = sl_utils.create_unit_service_area(unit=self.u3)
self.usa3 = sl_utils.create_unit_service_area(unit=self.u3)
qa_utils.create_unit_test_collection(unit=self.u1)
self.utc = qa_utils.create_unit_test_collection(unit=self.u2)
qa_utils.create_unit_test_collection(unit=self.u2)
qa_utils.create_unit_test_collection(unit=self.u3)
qa_utils.create_unit_test_collection(unit=self.u3)
qa_utils.create_unit_test_collection(unit=self.u3)
st = sl_utils.create_service_type()
sl_utils.create_service_event(
unit_service_area=self.usa1,
service_time=timezone.timedelta(minutes=60),
service_type=st)
sl_utils.create_service_event(
unit_service_area=self.usa2,
service_time=timezone.timedelta(minutes=60),
service_type=st)
sl_utils.create_service_event(
unit_service_area=self.usa2,
service_time=timezone.timedelta(minutes=60),
problem_description='problem on unit 3 or 2',
service_type=st)
sl_utils.create_service_event(
unit_service_area=self.usa3,
service_time=timezone.timedelta(minutes=60),
service_type=st)
sl_utils.create_service_event(
unit_service_area=self.usa3,
problem_description='problem on unit 3 or 2',
service_time=timezone.timedelta(minutes=60),
service_type=st)
sl_utils.create_service_event(
unit_service_area=self.usa3,
problem_description='problem on unit 3 or 2',
service_time=timezone.timedelta(minutes=60),
service_type=st)
def test_to_table(self):
site = USite.objects.create(name="site")
unit1 = utils.create_unit(site=site)
usa1 = sl_utils.create_unit_service_area(unit=unit1)
sl_utils.create_service_event(unit_service_area=usa1)
unit2 = utils.create_unit()
usa2 = sl_utils.create_unit_service_area(unit=unit2)
se = sl_utils.create_service_event(unit_service_area=usa2)
se2 = sl_utils.create_service_event(unit_service_area=usa2)
se.service_event_related.add(se2)
sl_utils.create_hours(service_event=se)
sl_utils.create_return_to_service_qa(service_event=se)
sl_utils.create_group_linker_instance(service_event=se)
part = sl_utils.create_part()
parts_models.PartUsed.objects.create(service_event=se, part=part, quantity=1)
attachment = Attachment(
attachment=ContentFile("content", "content.pdf"),
created_by=se.user_created_by,
serviceevent=se,
)
attachment.save()
rep = sl.ServiceEventDetailsReport(report_opts={'include_description': True})
rep.report_format = "csv"
context = rep.get_context()
table = rep.to_table(context)
header_row = table.index([
_("Service Event ID"),
_("Service Date"),
_("Site"),
_("Unit"),
_("Service Area"),
_("Service Type"),
_("Service Time"),
_("Lost Time"),
_("Status"),
_("Created By"),
_("Created Date"),
_("Modified By"),
_("Modified Date"),
_("Problem Description"),
_("Work Description"),
_("Safety Precautions"),
_("Initiated By"),
_("Related Service Events"),
_("Group Members Involved"),
_("Work Durations"),
_("Return To Service QC"),
_("Return To Service Comments"),
_("Parts Used"),
_("Attachments"),
_("Link"),
])
# should be three ses after header
assert len(table[header_row + 1:]) == 3
