def setUp(self):
super().setUp()
self.unit = utils.create_unit()
self.group = utils.create_group()
for p in Permission.objects.all():
self.group.permissions.add(p)
self.user.groups.add(self.group)
self.test_list = utils.create_test_list()
self.tnum_1 = utils.create_test(name="test1")
self.tnum_2 = utils.create_test(name="test2")
self.tcomp = utils.create_test(name="testc",
test_type=models.COMPOSITE)
self.tcomp.calculation_procedure = "result = test1 + test2 + 2"
self.tcomp.save()
self.tdate = utils.create_test(name="testdate", test_type=models.DATE)
self.tdatetime = utils.create_test(name="testdatetime",
test_type=models.DATETIME)
self.tmult = utils.create_test(name="testmult",
choices="choicea,choiceb",
test_type=models.MULTIPLE_CHOICE)
self.tstring = utils.create_test(name="teststring",
test_type=models.STRING)
self.tstringcomp = utils.create_test(name="teststringcomp",
test_type=models.STRING_COMPOSITE)
self.tstringcomp.calculation_procedure = "teststringcomp = teststring + testmult"
self.tstringcomp.save()
all_tests = [
self.tnum_1,
self.tnum_2,
self.tcomp,
self.tdate,
self.tdatetime,
self.tmult,
self.tstring,
self.tstringcomp,
]
for o, t in enumerate(all_tests):
utils.create_test_list_membership(self.test_list, t, order=o)
self.utc = utils.create_unit_test_collection(
unit=self.unit, test_collection=self.test_list)
self.utc.visible_to.add(self.group)
self.url = reverse("perform_qa", kwargs={'pk': self.utc.pk})
self.status = models.TestInstanceStatus.objects.create(
name="foo",
slug="foo",
is_default=True,
)
sl_utils.create_service_event_status(is_default=True)
sl_utils.create_unit_service_area(self.utc.unit)
sl_utils.create_service_type()
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_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 setUp(self):
self.usa1 = utils.create_unit_service_area()
self.usa2 = utils.create_unit_service_area()
self.sch1 = utils.create_service_event_schedule(
unit_service_area=self.usa1)
self.sch2 = utils.create_service_event_schedule(
unit_service_area=self.usa2)
self.unit_group = UnitGroup.objects.create(name="test group")
self.unit_group.units.add(self.usa1.unit)
self.group = models.Group.objects.latest('pk')
user = models.User.objects.latest('pk')
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()
self.notice = ServiceEventSchedulingNotice.objects.create(
recipients=self.recipients,
notification_type=ServiceEventSchedulingNotice.UPCOMING_AND_DUE,
future_days=7,
time="0:00",
)
# delete defaults schedules to make counting easier
Schedule.objects.all().delete()
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.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.groups.add(self.group)
user.is_active = True
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()
self.notice = ServiceEventReviewNotice.objects.create(
recipients=self.recipients,
notification_type=ServiceEventReviewNotice.UNREVIEWED,
time="0:00",
)
# delete defaults schedules to make counting easier
Schedule.objects.all().delete()
def test_to_table(self):
site = USite.objects.create(name="site")
unit = utils.create_unit(site=site)
usa = sl_utils.create_unit_service_area(unit=unit)
sl_utils.create_service_event_schedule(unit_service_area=usa)
usa2 = sl_utils.create_unit_service_area()
sl_utils.create_service_event_schedule(unit_service_area=usa2)
rep = sl.ScheduledTemplatesReport(report_opts={'active': True})
rep.report_format = "csv"
context = rep.get_context()
table = rep.to_table(context)
header_row = table.index([
_("Site"),
_("Unit"),
_("Service Area"),
_("Template Name"),
_("Frequency"),
_("Assigned To"),
_("Link"),
])
assert len(table[header_row + 1:]) == 2
def test_unique_together(self):
sl_utils.create_unit_service_area(unit=self.u, service_area=self.sa)
with self.assertRaises(IntegrityError):
sl_models.UnitServiceArea.objects.create(unit=self.u,
service_area=self.sa)
def test_with_service_area(self):
"""If we filter for service area, the searcher should only return
templates where the service_area is correct"""
# one template with correct service type
sa1 = sl_utils.create_service_area()
t1 = self.create_template("1", service_area=sa1)
sl_utils.create_unit_service_area(
unit=self.unit,
service_area=sa1,
)
# one template with incorrect service area
sa2 = sl_utils.create_service_area()
self.create_template("2", service_area=sa2)
# one template with no service_area
self.create_template("3")
resp = self.client.get(self.url,
data={
'unit': self.unit.id,
'service_area': sa1.pk
})
data = resp.json()
assert len(data) == 1
assert data[0]['id'] == t1.id
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 test_to_table(self):
site = USite.objects.create(name="site")
unit = utils.create_unit(site=site)
usa = sl_utils.create_unit_service_area(unit=unit)
sch1 = sl_utils.create_service_event_schedule(unit_service_area=usa)
sch1.due_date = timezone.now() - timezone.timedelta(days=1)
sch1.save()
unit2 = utils.create_unit(site=None)
usa2 = sl_utils.create_unit_service_area(unit=unit2)
sl_utils.create_service_event_schedule(unit_service_area=usa2)
rep = sl.NextScheduledServiceEventsDueDatesReport()
rep.report_format = "csv"
context = rep.get_context()
table = rep.to_table(context)
header_count = table.count([
_("Unit"),
_("Service Area"),
_("Template Name"),
_("Frequency"),
_("Due Date"),
_("Window"),
_("Assigned To"),
_("Perform")
])
assert header_count == 2
def setUp(self):
self.usa1 = utils.create_unit_service_area()
self.usa2 = utils.create_unit_service_area()
self.sch1 = utils.create_service_event_schedule(
unit_service_area=self.usa1)
self.sch2 = utils.create_service_event_schedule(
unit_service_area=self.usa2)
self.unit_group = UnitGroup.objects.create(name="test group")
self.unit_group.units.add(self.usa1.unit)
self.group = models.Group.objects.latest('pk')
user = models.User.objects.latest('pk')
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_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_generate_summary_html(self):
site = USite.objects.create(name="site")
unit = utils.create_unit(site=site)
usa = sl_utils.create_unit_service_area(unit=unit)
sl_utils.create_service_event_schedule(unit_service_area=usa)
rep = sl.ScheduledTemplatesReport()
rep.report_format = "pdf"
rep.to_html()
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_generate_next_due_dates_html(self):
site = USite.objects.create(name="site")
unit = utils.create_unit(site=site)
usa = sl_utils.create_unit_service_area(unit=unit)
sch = sl_utils.create_service_event_schedule(unit_service_area=usa)
sch.due_date = timezone.now() + timezone.timedelta(days=1)
sch.save()
rep = sl.NextScheduledServiceEventsDueDatesReport()
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_delete_unit_service_area_variables(self):
# unit > Cascade
# service_area > Cascade
usa = sl_utils.create_unit_service_area()
u = usa.unit
usa_id = usa.id
u.delete()
self.assertFalse(
sl_models.UnitServiceArea.objects.filter(id=usa_id).exists())
usa = sl_utils.create_unit_service_area()
sa = usa.service_area
usa_id = usa.id
sa.delete()
self.assertFalse(
sl_models.UnitServiceArea.objects.filter(id=usa_id).exists())
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)
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 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 setUp(self):
self.factory = RequestFactory()
self.view = views.CreateServiceEvent.as_view()
self.default_ses = sl_utils.create_service_event_status(
is_default=True)
sl_utils.create_service_event_status()
qa_utils.create_status(is_default=True)
now = timezone.now()
self.u_1 = qa_utils.create_unit(name='u_1')
self.sa_1 = sl_utils.create_service_area(name='sa_1')
self.usa_1 = sl_utils.create_unit_service_area(unit=self.u_1,
service_area=self.sa_1)
self.tl_1 = qa_utils.create_test_list(name='tl_1')
self.tli_1_1 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_1, test_collection=self.tl_1),
test_list=self.tl_1,
work_completed=now - timezone.timedelta(hours=1))
self.tli_1_2 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_1, test_collection=self.tl_1),
test_list=self.tl_1,
work_completed=now)
self.se_1 = sl_utils.create_service_event(unit_service_area=self.usa_1)
self.u_2 = qa_utils.create_unit(name='u_2')
self.sa_2 = sl_utils.create_service_area(name='sa_2')
self.usa_2 = sl_utils.create_unit_service_area(unit=self.u_2,
service_area=self.sa_2)
self.tl_2 = qa_utils.create_test_list(name='tl_2')
self.tli_2_1 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_2, test_collection=self.tl_2),
test_list=self.tl_2,
work_completed=now - timezone.timedelta(hours=1))
self.tli_2_2 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_2, test_collection=self.tl_2),
test_list=self.tl_2,
work_completed=now)
self.se_2 = sl_utils.create_service_event(unit_service_area=self.usa_2)
self.url = reverse('sl_new')
self.url_delete = reverse('se_delete')
self.user = create_user(is_superuser=True)
self.client.login(username='******', password='******')
perm = Permission.objects.get(codename='can_have_hours')
user_can_hours = User.objects.get(username='******')
user_can_hours.user_permissions.add(perm)
user_group_has_hours = create_user(uname='in_group_with_hours')
group_has_hours = create_group(name='can_have_hours')
group_has_hours.permissions.add(perm)
user_group_has_hours.groups.add(group_has_hours)
sl_utils.create_third_party()
group_linked = create_group(name='linked')
user_group_linked = create_user(uname='user_in_group_linked')
user_group_linked.groups.add(group_linked)
self.gl_1 = sl_utils.create_group_linker(group=group_linked)
self.part = sl_utils.create_part(add_storage=True)
self.st = sl_utils.create_service_type()
self.sto = sl_utils.create_storage(quantity=2)
def test_str(self):
usa = sl_utils.create_unit_service_area(unit=self.u,
service_area=self.sa)
self.assertTrue(self.u.name in str(usa) and self.sa.name in str(usa))
def setUp(self):
self.factory = RequestFactory()
self.view = views.UpdateServiceEvent.as_view()
self.default_ses = sl_utils.create_service_event_status(
is_default=True)
self.approved_ses = sl_utils.create_service_event_status(
is_review_required=False, rts_qa_must_be_reviewed=True)
sl_utils.create_service_event_status()
qa_utils.create_status(is_default=True)
now = timezone.now()
self.u_1 = qa_utils.create_unit(name='u_1')
self.sa_1 = sl_utils.create_service_area(name='sa_1')
self.usa_1 = sl_utils.create_unit_service_area(unit=self.u_1,
service_area=self.sa_1)
self.tl_1 = qa_utils.create_test_list(name='tl_1')
self.tli_1_1 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_1, test_collection=self.tl_1),
test_list=self.tl_1,
work_completed=now - timezone.timedelta(hours=1))
self.tli_1_2 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_1, test_collection=self.tl_1),
test_list=self.tl_1,
work_completed=now)
self.se_1 = sl_utils.create_service_event(unit_service_area=self.usa_1)
self.u_2 = qa_utils.create_unit(name='u_2')
self.sa_2 = sl_utils.create_service_area(name='sa_2')
self.usa_2 = sl_utils.create_unit_service_area(unit=self.u_2,
service_area=self.sa_2)
self.tl_2 = qa_utils.create_test_list(name='tl_2')
self.tli_2_1 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_2, test_collection=self.tl_2),
test_list=self.tl_2,
work_completed=now - timezone.timedelta(hours=1))
self.tli_2_2 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_2, test_collection=self.tl_2),
test_list=self.tl_2,
work_completed=now)
self.se_2 = sl_utils.create_service_event(unit_service_area=self.usa_2)
self.url = reverse('sl_new')
self.user = create_user(is_superuser=True)
self.client.login(username='******', password='******')
perm = Permission.objects.get(codename='can_have_hours')
user_can_hours = User.objects.get(username='******')
user_can_hours.user_permissions.add(perm)
user_group_has_hours = create_user(uname='in_group_with_hours')
group_has_hours = create_group(name='can_have_hours')
group_has_hours.permissions.add(perm)
user_group_has_hours.groups.add(group_has_hours)
sl_utils.create_third_party()
group_linked = create_group(name='linked')
user_group_linked = create_user(uname='user_in_group_linked')
user_group_linked.groups.add(group_linked)
self.gl_1 = sl_utils.create_group_linker(group=group_linked)
self.part = sl_utils.create_part(add_storage=True)
self.st = sl_utils.create_service_type()
self.se = sl_utils.create_service_event(
unit_service_area=self.usa_1,
service_status=self.default_ses,
service_type=self.st)
self.url = reverse('sl_edit', kwargs={"pk": self.se.pk})
self.data = {
'datetime_service': format_datetime(timezone.now()),
'service_status': self.default_ses.id,
'service_type': self.st.id,
'is_review_required': 0,
'safety_precautions': 'safety_precautions',
'problem_description': 'problem_description',
'service_area_field': self.se.unit_service_area.service_area.id,
'unit_field': self.se.unit_service_area.unit.id,
'unit_field_fake': self.se.unit_service_area.unit.id,
'qafollowup_notes': 'qafollowup_notes',
'test_list_instance_initiated_by': self.tli_1_1.id,
'duration_lost_time': '0100',
'duration_service_time': '0100',
'hours-INITIAL_FORMS': 0,
'hours-MAX_NUM_FORMS': 1000,
'hours-TOTAL_FORMS': 0,
'hours-MIN_NUM_FORMS': 0,
'parts-INITIAL_FORMS': 0,
'parts-MAX_NUM_FORMS': 1000,
'parts-TOTAL_FORMS': 0,
'parts-MIN_NUM_FORMS': 0,
'rtsqa-INITIAL_FORMS': 0,
'rtsqa-MAX_NUM_FORMS': 1000,
'rtsqa-TOTAL_FORMS': 0,
'rtsqa-MIN_NUM_FORMS': 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)
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
