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_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 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 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.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 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_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_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 test_generate_summary_html(self):
site = USite.objects.create(name="site")
unit = utils.create_unit(site=site)
utils.create_unit_test_collection(unit=unit)
rep = qc.AssignedQCDetailsReport()
rep.report_format = "pdf"
rep.to_html()
def test_admin_set_ref_tols(self):
utils.create_tolerance(tol_type=models.MULTIPLE_CHOICE,
mc_pass_choices="a,b")
utils.create_tolerance()
for the_test in objects['Tests']:
if the_test['test_type'] == models.MULTIPLE_CHOICE:
if not utils.exists('qa', 'Test', 'name', the_test['name']):
mult_test = utils.create_test(
test_type=models.MULTIPLE_CHOICE,
choices=the_test['choices'],
name=the_test['name'])
elif the_test['test_type'] == models.SIMPLE:
if not utils.exists('qa', 'Test', 'name', the_test['name']):
simp_test = utils.create_test(test_type=models.SIMPLE,
name=the_test['name'])
elif the_test['test_type'] == models.COMPOSITE:
if not utils.exists('qa', 'Test', 'name', the_test['name']):
comp_test = utils.create_test(test_type=models.COMPOSITE,
name=the_test['name'])
if not utils.exists('qa', 'TestList', 'name',
objects['TestList']['name']):
test_list = utils.create_test_list(objects['TestList']['name'])
utils.create_test_list_membership(test_list=test_list,
test=mult_test)
utils.create_test_list_membership(test_list=test_list,
test=simp_test)
utils.create_test_list_membership(test_list=test_list,
test=comp_test)
utils.create_unit_test_collection(test_collection=test_list)
self.load_admin()
self.click_by_link_text('Set References & Tolerances')
self.click_by_link_text(mult_test.name)
self.wait.until(
e_c.presence_of_element_located((By.ID, 'id_tolerance')))
self.select_by_index("id_tolerance", 1)
self.driver.find_element_by_name('_save').click()
self.wait_for_success()
self.driver.find_element_by_link_text('simple').click()
self.select_by_index("id_tolerance", 1)
self.driver.find_element_by_id('id_reference_value').send_keys('0')
self.driver.find_element_by_name('_save').click()
self.wait_for_success()
self.driver.find_element_by_link_text('composite').click()
self.select_by_index("id_tolerance", 1)
self.driver.find_element_by_id('id_reference_value').send_keys('23.23')
self.driver.find_element_by_name('_save').click()
self.wait_for_success()
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_to_table_group_by_unit_test_date_csv(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)
ti = utils.create_test_instance(test_list_instance=tli)
utils.create_test_instance(
test_list_instance=tli,
unit_test_info=ti.unit_test_info,
work_completed=tli.work_completed - timezone.timedelta(days=1),
)
ti3 = utils.create_test_instance(
test_list_instance=tli,
work_completed=tli.work_completed - timezone.timedelta(days=1),
)
rep = qc.TestInstanceDetailsReport(
report_opts={
'unit_test_info__test':
[ti.unit_test_info.test.pk, ti3.unit_test_info.test.pk],
'organization':
'group_by_unit_test_date'
})
rep.report_format = "csv"
context = rep.get_context()
table = rep.to_table(context)
org_row = table.index(['Organization:', 'Group by Unit/Test/Date'])
# should be two rows after blank row
assert len(table[org_row + 2:]) == 2
# and 11 columns
assert len(table[org_row + 3]) == 11
def test_to_table_one_per_row_csv(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)
ti = utils.create_test_instance(test_list_instance=tli)
utils.create_test_instance(
test_list_instance=tli,
unit_test_info=ti.unit_test_info,
work_completed=tli.work_completed - timezone.timedelta(days=1),
)
rep = qc.TestInstanceDetailsReport(
report_opts={
'unit_test_info__test': [ti.unit_test_info.test.pk],
'organization': 'one_per_row'
})
rep.report_format = "csv"
context = rep.get_context()
table = rep.to_table(context)
header_row = table.index([
_("Work Completed"),
_("Test"),
_("Unit"),
_("Site"),
_("Value"),
_("Reference"),
_("Tolerance"),
_("Skipped"),
_("Performed By"),
_("Comment"),
])
# should be two tis after header
assert len(table[header_row + 1:]) == 2
def create_return_to_service_qa(service_event=None,
unit_test_collection=None,
user_assigned_by=None,
datetime_assigned=timezone.now(),
add_test_list_instance=False):
if service_event is None:
service_event = create_service_event()
if unit_test_collection is None:
unit_test_collection = qa_utils.create_unit_test_collection()
if user_assigned_by is None:
user_assigned_by = create_user()
rtsqa, _ = models.ReturnToServiceQA.objects.get_or_create(
service_event=service_event,
unit_test_collection=unit_test_collection,
user_assigned_by=user_assigned_by,
datetime_assigned=datetime_assigned)
if add_test_list_instance:
if isinstance(add_test_list_instance, qa_models.TestListInstance):
tli = add_test_list_instance
else:
tli = qa_utils.create_test_list_instance(
unit_test_collection=unit_test_collection)
rtsqa.test_list_instance = tli
rtsqa.save()
return rtsqa
def setUp(self):
self.tests = []
self.ref = models.Reference(type=models.NUMERICAL, value=100.)
self.tol = models.Tolerance(type=models.PERCENT, act_low=-3, tol_low=-2, tol_high=2, act_high=3)
self.values = [None, None, 96, 97, 100, 100]
self.statuses = [utils.create_status(name="status%d" % x, slug="status%d" % x) for x in range(len(self.values))]
self.test_list = utils.create_test_list()
for i in range(6):
test = utils.create_test(name="name%d" % i)
self.tests.append(test)
utils.create_test_list_membership(self.test_list, test)
self.unit_test_collection = utils.create_unit_test_collection(test_collection=self.test_list)
self.test_list_instance = self.create_test_list_instance()
self.group = models.Group.objects.get(pk=1)
user = models.User.objects.get(pk=1)
user.groups.add(self.group)
user.email = "*****@*****.**"
user.save()
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.ref = models.Reference(type=models.NUMERICAL, value=100.)
self.tol = models.Tolerance(type=models.PERCENT,
act_low=-3,
tol_low=-2,
tol_high=2,
act_high=3)
self.values = [None, None, 96, 97, 100, 100]
self.statuses = [
utils.create_status(name="status%d" % x, slug="status%d" % x)
for x in range(len(self.values))
]
self.test_list = utils.create_test_list()
for i in range(6):
test = utils.create_test(name="name%d" % i)
self.tests.append(test)
utils.create_test_list_membership(self.test_list, test)
self.unit_test_collection = utils.create_unit_test_collection(
test_collection=self.test_list)
self.test_list_instance = self.create_test_list_instance()
self.group = models.Group.objects.get(pk=1)
user = models.User.objects.get(pk=1)
user.groups.add(self.group)
user.email = "*****@*****.**"
user.save()
def test_to_table(self):
site = USite.objects.create(name="site")
unit = utils.create_unit(site=site)
tlm = utils.create_test_list_membership()
utils.create_unit_test_collection(unit=unit,
test_collection=tlm.test_list)
unit2 = utils.create_unit(site=None)
utils.create_unit_test_collection(unit=unit2,
test_collection=tlm.test_list)
rep = qc.AssignedQCDetailsReport(report_opts={'active': True})
rep.report_format = "csv"
context = rep.get_context()
rep.to_table(context)
def test_load_autosave(self):
"""Ensure that no failed tests on load and 3 "NO TOL" tests present"""
tl2 = utils.create_test_list(name="day 2")
utils.create_test_list_membership(tl2, test=self.tnum_1)
cycle = utils.create_cycle([self.test_list, tl2])
utc = utils.create_unit_test_collection(
unit=self.utc.unit,
test_collection=cycle,
assigned_to=self.utc.assigned_to)
tz = timezone.get_current_timezone()
auto = models.AutoSave.objects.create(
unit_test_collection=utc,
test_list=tl2,
day=1,
work_started=tz.localize(timezone.datetime(1980, 5, 12, 12)),
work_completed=tz.localize(timezone.datetime(1980, 5, 12, 12, 1)),
created_by=self.user,
modified_by=self.user,
data={
'tests': {
'test1': 1,
},
'comments': {
'test1': 'test comment',
},
'skips': {
'test1': False,
},
'tli_comment': 'test list instance comment'
})
self.login()
url = reverse("perform_qa", kwargs={'pk': utc.pk})
self.open(url + "?autosave_id=%d&day=%d" % (auto.pk, auto.day + 1))
time.sleep(0.2)
inputs = self.driver.find_elements_by_class_name("qa-input")[:3]
title = "Perform %s : day 2" % utc.unit.name
assert title in [
el.text
for el in self.driver.find_elements_by_class_name("box-title")
]
assert float(inputs[0].get_attribute("value")) == 1
assert self.driver.find_element_by_id("id_work_started").get_attribute(
"value") == "12 May 1980 12:00"
assert self.driver.find_element_by_id(
"id_work_completed").get_attribute("value") == "12 May 1980 12:01"
assert self.driver.find_element_by_id(
"id_work_duration").get_attribute("value") == "0hr:01min"
assert self.driver.find_element_by_id(
"id_form-0-comment").get_attribute("value") == "test comment"
assert self.driver.find_element_by_id("id_comment").get_attribute(
"value") == "test list instance comment"
def test_generate_due_and_overdue_html(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)
utils.create_test_instance(test_list_instance=tli)
rep = qc.DueAndOverdueQCReport()
rep.report_format = "pdf"
rep.to_html()
def setUp(self):
self.user = create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
self.u_1 = qa_utils.create_unit()
self.u_2 = qa_utils.create_unit()
self.f_1 = qa_utils.create_frequency()
self.f_2 = qa_utils.create_frequency()
self.tl_1 = qa_utils.create_test_list()
self.tl_2 = qa_utils.create_test_list()
self.t_1 = qa_utils.create_test()
self.t_2 = qa_utils.create_test()
qa_utils.create_test_list_membership(test_list=self.tl_1, test=self.t_1)
qa_utils.create_test_list_membership(test_list=self.tl_1, test=self.t_2)
self.g_1 = create_group()
self.g_2 = create_group()
self.tl_ct = ContentType.objects.get(model='testlist')
self.tlc_ct = ContentType.objects.get(model='testlistcycle')
self.utc_1 = qa_utils.create_unit_test_collection(
unit=self.u_1, test_collection=self.tl_1, assigned_to=self.g_1, frequency=self.f_1
)
self.utc_2 = qa_utils.create_unit_test_collection(
unit=self.u_2, active=False, assigned_to=self.g_2, frequency=self.f_2
)
self.url_list = reverse(
'admin:%s_%s_changelist' % (
qa_models.UnitTestCollection._meta.app_label, qa_models.UnitTestCollection._meta.model_name
)
)
self.url_add = reverse(
'admin:%s_%s_add' % (
qa_models.UnitTestCollection._meta.app_label, qa_models.UnitTestCollection._meta.model_name
)
)
self.url_change = reverse(
'admin:%s_%s_change' % (
qa_models.UnitTestCollection._meta.app_label, qa_models.UnitTestCollection._meta.model_name
),
args=[self.utc_1.id]
)
def setUp(self):
self.tests = []
self.ref = models.Reference(type=models.NUMERICAL, value=100.)
self.tol = models.Tolerance(type=models.PERCENT,
act_low=-3,
tol_low=-2,
tol_high=2,
act_high=3)
self.ref.created_by = utils.create_user()
self.tol.created_by = utils.create_user()
self.ref.modified_by = utils.create_user()
self.tol.modified_by = utils.create_user()
self.values = [None, None, 96, 97, 100, 100]
self.statuses = [
utils.create_status(name="status%d" % x, slug="status%d" % x)
for x in range(len(self.values))
]
self.test_list = utils.create_test_list()
for i in range(6):
test = utils.create_test(name="name%d" % i)
self.tests.append(test)
utils.create_test_list_membership(self.test_list, test)
self.testlist_group = TestListGroup.objects.create(name="test group")
self.testlist_group.test_lists.add(self.test_list)
self.unit_test_collection = utils.create_unit_test_collection(
test_collection=self.test_list)
self.unit_group = UnitGroup.objects.create(name="test group")
self.unit_group.units.add(self.unit_test_collection.unit)
self.test_list_instance = self.create_test_list_instance()
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_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 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.tli1 = utils.create_test_list_instance(
unit_test_collection=self.utc1)
self.tli1.all_reviewed = False
self.tli1.save()
self.tli2 = utils.create_test_list_instance(
unit_test_collection=self.utc2)
self.tli2.all_reviewed = True
self.tli2.save()
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()
# delete defaults schedules to make counting easier
Schedule.objects.all().delete()
def test_generate_html(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)
tli2 = utils.create_test_list_instance(unit_test_collection=utc2)
comment = Comment(
submit_date=timezone.now(),
user=tli2.created_by,
content_object=tli2,
comment='test comment',
site=Site.objects.latest("pk"),
)
comment.save()
rep = qc.TestListInstanceDetailsReport(
report_opts={'unit_test_collection': [utc.pk]})
rep.report_format = "pdf"
rep.to_html()
def test_generate_html_group_by_unit_test_date(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)
ti = utils.create_test_instance(test_list_instance=tli)
rep = qc.TestInstanceDetailsReport(
report_opts={
'unit_test_info__test': [ti.unit_test_info.test.pk],
'organization': 'group_by_unit_test_date'
})
rep.report_format = "pdf"
assert 'not supported for' in rep.to_html()
def test_generate_html_one_per_row(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)
ti = utils.create_test_instance(test_list_instance=tli)
rep = qc.TestInstanceDetailsReport(
report_opts={
'unit_test_info__test': [ti.unit_test_info.test.pk],
'organization': 'one_per_row'
})
rep.report_format = "pdf"
rep.to_html()
def test_email_not_sent_to_group_for_excluded_unit(self):
"""TLI is created on 2nd unit so no one should get an email"""
utc2 = utils.create_unit_test_collection(
test_collection=self.test_list)
QCCompletedNotice.objects.create(
notification_type=QCCompletedNotice.TOLERANCE,
recipients=self.recipients,
units=self.unit_group,
)
tli = self.create_test_list_instance(utc=utc2)
signals.testlist_complete.send(sender=self, instance=tli, created=True)
self.assertEqual(len(mail.outbox), 0)
def test_email_not_sent_for_same_testlist_different_unit(self):
unit = utils.create_unit()
utc = utils.create_unit_test_collection(unit=unit,
test_collection=self.test_list)
QCCompletedNotice.objects.create(
notification_type=QCCompletedNotice.COMPLETED,
test_lists=self.testlist_group,
units=self.unit_group,
recipients=self.recipients,
)
tli = self.create_test_list_instance(utc=utc)
signals.testlist_complete.send(sender=self, instance=tli, created=True)
assert len(mail.outbox) == 0
def test_email_not_sent_for_diff_testlist(self):
new_test_list = utils.create_test_list()
test = utils.create_test(name="new tl name")
utils.create_test_list_membership(new_test_list, test)
utc = utils.create_unit_test_collection(
unit=self.unit_test_collection.unit, test_collection=new_test_list)
QCCompletedNotice.objects.create(
notification_type=QCCompletedNotice.COMPLETED,
recipients=self.recipients,
test_lists=self.testlist_group,
)
tli = self.create_test_list_instance(utc=utc)
signals.testlist_complete.send(sender=self, instance=tli, created=True)
assert len(mail.outbox) == 0
def create_service_event(unit_service_area=None,
service_type=None,
service_status=None,
user_created_by=None,
datetime_service=timezone.now(),
problem_description='problem_description',
is_review_required=False,
datetime_created=timezone.now(),
add_test_list_instance_initiated_by=False,
service_time=None,
lost_time=None):
if unit_service_area is None:
unit_service_area = create_unit_service_area()
if service_type is None:
service_type = create_service_type()
if service_status is None:
service_status = create_service_event_status()
if user_created_by is None:
user_created_by = create_user()
se, _ = models.ServiceEvent.objects.get_or_create(
unit_service_area=unit_service_area,
service_type=service_type,
service_status=service_status,
user_created_by=user_created_by,
datetime_service=datetime_service,
problem_description=problem_description,
is_review_required=is_review_required,
datetime_created=datetime_created,
duration_service_time=service_time,
duration_lost_time=lost_time)
if add_test_list_instance_initiated_by:
if isinstance(add_test_list_instance_initiated_by,
qa_models.TestListInstance):
se.test_list_instance_initiated_by = add_test_list_instance_initiated_by
else:
utc = qa_utils.create_unit_test_collection(
unit=unit_service_area.unit)
se.test_list_instance_initiated_by = qa_utils.create_test_list_instance(
unit_test_collection=utc)
se.save()
return se
