def test_to_table(self):
site = USite.objects.create(name="site")
unit = utils.create_unit(site=site)
utils.create_unit_test_collection(unit=unit)
tlm = utils.create_test_list_membership()
unit2 = utils.create_unit(site=None)
utils.create_unit_test_collection(unit=unit2,
test_collection=tlm.test_list)
rep = qc.AssignedQCReport(report_opts={'active': True})
rep.report_format = "csv"
context = rep.get_context()
table = rep.to_table(context)
header_row = table.index([
_("Site"),
_("Unit"),
_("Test list (Cycle)"),
_("Frequency"),
_("Assigned To"),
_("Link"),
])
assert len(table[header_row + 1:]) == 2
def setUp(self):
self.unit1 = utils.create_unit(name="unit1", number=1)
self.unit2 = utils.create_unit(name="unit2", number=2)
self.utc1 = utils.create_unit_test_collection(unit=self.unit1)
self.utc2 = utils.create_unit_test_collection(unit=self.unit2)
self.testlist_group = TestListGroup.objects.create(name="test group")
self.testlist_group.test_lists.add(self.utc1.tests_object)
self.unit_group = UnitGroup.objects.create(name="test group")
self.unit_group.units.add(self.utc1.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 = QCReviewNotice.objects.create(
recipients=self.recipients,
notification_type=QCReviewNotice.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)
utc = utils.create_unit_test_collection(unit=unit)
utils.create_test_list_instance(unit_test_collection=utc)
unit2 = utils.create_unit(site=None)
utc2 = utils.create_unit_test_collection(unit=unit2)
utils.create_test_list_instance(unit_test_collection=utc2)
rep = qc.TestListInstanceSummaryReport()
rep.report_format = "csv"
context = rep.get_context()
table = rep.to_table(context)
header_row = table.index([
'Site',
'Unit',
'Test list',
'Due Date',
'Work Completed',
'Pass/Fail Status',
'Link',
])
# should be two tlis after header
assert len(table[header_row + 1:]) == 2
def setUp(self):
self.unit1 = utils.create_unit(name="unit1", number=1)
self.unit2 = utils.create_unit(name="unit2", number=2)
self.utc1 = utils.create_unit_test_collection(unit=self.unit1)
self.utc2 = utils.create_unit_test_collection(unit=self.unit2)
self.unit_group = UnitGroup.objects.create(name="test group")
self.unit_group.units.add(self.utc1.unit)
self.group = Group.objects.latest('pk')
self.user = User.objects.latest('pk')
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 = 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 = ServiceEventNotice.objects.create(
recipients=self.recipients,
notification_type=ServiceEventNotice.UPDATED_OR_CREATED,
)
# delete defaults schedules to make counting easier
Schedule.objects.all().delete()
self.sa = sl_utils.create_service_area()
def test_to_table(self):
site = USite.objects.create(name="site")
unit = utils.create_unit(site=site)
utc = utils.create_unit_test_collection(unit=unit)
utils.create_test_list_instance(unit_test_collection=utc)
unit2 = utils.create_unit(site=None)
utc2 = utils.create_unit_test_collection(unit=unit2)
utils.create_test_list_instance(unit_test_collection=utc2)
rep = qc.NextDueDatesReport()
rep.report_format = "csv"
context = rep.get_context()
table = rep.to_table(context)
header_count = table.count([
_("Unit"),
_("Name"),
_("Frequency"),
_("Due Date"),
_("Window"),
_("Assigned To"),
_("Perform")
])
assert header_count == 2
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 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_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(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):
create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
self.url = reverse('qa_copy_refs_and_tols')
self.tl_1 = qa_utils.create_test_list()
self.tl_2 = qa_utils.create_test_list()
self.tl_3 = qa_utils.create_test_list()
self.tl_fc_1 = qa_utils.create_test_list(name='for_cycle_1')
self.tl_fc_2 = qa_utils.create_test_list(name='for_cycle_2')
self.tl_fc_3 = qa_utils.create_test_list(name='for_cycle_3')
self.tlc_1 = qa_utils.create_cycle(test_lists=[self.tl_fc_1, self.tl_fc_2, self.tl_fc_3])
self.tlc_2 = qa_utils.create_cycle(test_lists=[self.tl_fc_1, self.tl_fc_2])
self.u_1 = qa_utils.create_unit()
self.u_2 = qa_utils.create_unit()
test = qa_utils.create_test()
self.tlm_1 = qa_utils.create_test_list_membership(test_list=self.tl_1, test=test)
self.tlm_2 = qa_utils.create_test_list_membership(test_list=self.tl_2, test=test)
self.utc_1 = qa_utils.create_unit_test_collection(unit=self.u_1, test_collection=self.tl_1)
self.utc_2 = qa_utils.create_unit_test_collection(unit=self.u_2, test_collection=self.tl_2)
self.uti_1, _ = qa_models.UnitTestInfo.objects.get_or_create(unit=self.u_1, test=test)
self.uti_1.reference = qa_utils.create_reference()
self.uti_1.tolerance = qa_utils.create_tolerance()
self.uti_1.save()
self.uti_2, _ = qa_models.UnitTestInfo.objects.get_or_create(unit=self.u_2, test=test)
def setUp(self):
self.url = reverse('get_unit_info')
utils.create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
self.u1 = utils.create_unit()
self.u2 = utils.create_unit()
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 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 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_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 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_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_get_tlis_for_site(self):
site = USite.objects.create(name="site")
unit = utils.create_unit(site=site)
utc = utils.create_unit_test_collection(unit=unit)
tli = utils.create_test_list_instance(unit_test_collection=utc)
unit2 = utils.create_unit(site=None)
utc2 = utils.create_unit_test_collection(unit=unit2)
utils.create_test_list_instance(unit_test_collection=utc2)
qs = TestListInstance.objects.all()
tlis = qc.TestListInstanceSummaryReport().get_tlis_for_site(qs, site)
assert list([x.pk for x in tlis]) == [tli.pk]
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_with_rts(self):
"""If we filter for a unit, the searcher should only return
templates where the return to service test lists are all
assigned to that unit."""
tl1 = qa_utils.create_test_list()
tl2 = qa_utils.create_test_list()
u1 = qa_utils.create_unit()
qa_utils.create_unit_test_collection(unit=u1, test_collection=tl1)
# one template with RTS that is assigned to the unit
t1 = self.create_template("1")
t1.return_to_service_test_lists.add(tl1)
# one template with RTS that is not assigned to the unit
t2 = self.create_template("2")
t2.return_to_service_test_lists.add(tl2)
# one template with not RTS
t3 = self.create_template("3")
resp = self.client.get(self.url, data={'unit': u1.pk})
data = resp.json()
assert len(data) == 2
assert [t['id'] for t in data] == [t1.id, t3.id]
def test_with_rts_and_service_type(self):
"""If we filter for a unit, and service type, the searcher should only return
templates where the return to service test lists are all
assigned to that unit and the template has the correct service_type."""
st = sl_utils.create_service_type()
tl1 = qa_utils.create_test_list()
tl2 = qa_utils.create_test_list()
u1 = qa_utils.create_unit()
qa_utils.create_unit_test_collection(unit=u1, test_collection=tl1)
# one template with RTS that is assigned to the unit
t1 = self.create_template("1", service_type=st)
t1.return_to_service_test_lists.add(tl1)
# one template with RTS that is not assigned to the unit
t2 = self.create_template("2", service_type=st)
t2.return_to_service_test_lists.add(tl2)
# one template with no RTS and correct service_type
t3 = self.create_template("3", service_type=st)
# one template with no RTS and no service_type
self.create_template("4")
resp = self.client.get(self.url,
data={
'unit': u1.pk,
'service_type': st.pk
})
data = resp.json()
assert len(data) == 2
assert [t['id'] for t in data] == [t1.id, t3.id]
def create_fault(unit=None,
occurred=None,
fault_type=None,
user=None,
modality=None):
user = user or qa_utils.create_user()
unit = unit or qa_utils.create_unit()
fault_type = fault_type or create_fault_type()
occurred = occurred or timezone.now()
f = models.Fault.objects.create(
unit=unit,
modality=modality,
created_by=user,
modified_by=user,
occurred=occurred,
)
try:
for ft in fault_type:
f.fault_types.add(ft)
except TypeError:
f.fault_types.add(fault_type)
return f
def setUp(self):
self.user = qa_utils.create_user()
self.unit = qa_utils.create_unit()
self.fault_type = FaultType.objects.create(code="ABC", slug="abc")
user = User.objects.create_superuser("faultuser", "*****@*****.**",
"password")
self.client.force_login(user)
def setUp(self):
self.user = qa_utils.create_user()
self.unit = qa_utils.create_unit()
self.url = reverse("fault_type_autocomplete")
user = User.objects.create_superuser("faultuser", "*****@*****.**",
"password")
self.client.force_login(user)
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 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.tests = []
self.unit = qa_utils.create_unit()
self.unit_group = UnitGroup.objects.create(name="test group")
self.unit_group.units.add(self.unit)
self.group = create_group()
user = create_user()
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_dueandoverdue_unit_site_choices(self):
s = utils.create_site()
u = utils.create_unit(site=s)
f = filters.UnitTestCollectionFilter()
choices = [('%s :: %s' % (s.name, u.type.name), [(u.id, '%s :: %s' % (s.name, u.name))])]
assert list(f.form.fields['unit'].choices) == choices
