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.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 create_test_instance(
test_list_instance=None, unit_test_info=None, value=1., created_by=None, work_completed=None, status=None
):
if test_list_instance is None:
test_list_instance = create_test_list_instance()
if unit_test_info is None:
unit_test_info = create_unit_test_info()
if work_completed is None:
work_completed = timezone.now()
work_started = work_completed - timezone.timedelta(seconds=60)
if created_by is None:
created_by = create_user()
if status is None:
status = create_status()
ti = models.TestInstance(
unit_test_info=unit_test_info,
value=value,
created_by=created_by,
modified_by=created_by,
status=status,
work_completed=work_completed,
work_started=work_started,
test_list_instance=test_list_instance
)
ti.save()
return ti
def create_test(
name=None,
test_type=models.SIMPLE,
choices=None,
procedure=None,
constant_value=None,
category=None,
wrap_low=None,
wrap_high=None,
):
user = create_user()
if name is None or models.Test.objects.filter(name=name).count() > 0:
name = "test_%d" % models.Test.objects.count()
test = models.Test(
name=name,
slug=name,
description="desc",
type=test_type,
category=category or create_category(),
created_by=user,
modified_by=user,
choices=choices,
wrap_high=wrap_high,
wrap_low=wrap_low,
procedure=procedure,
constant_value=constant_value
)
test.save()
return test
def setUp(self):
self.user = create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
qa_utils.create_test_instance()
self.url = reverse(
'admin:%s_%s_changelist' % (qa_models.TestInstance._meta.app_label, qa_models.TestInstance._meta.model_name)
)
def create_tolerance(tol_type=models.ABSOLUTE, act_low=-2, tol_low=-1, tol_high=1, act_high=2, created_by=None,
mc_pass_choices='', mc_tol_choices=''):
if created_by is None:
created_by = create_user()
kwargs = dict(
type=tol_type,
act_low=act_low,
tol_low=tol_low,
tol_high=tol_high,
act_high=act_high,
created_by=created_by, modified_by=created_by
)
if tol_type == models.MULTIPLE_CHOICE:
kwargs = dict(
type=tol_type,
mc_tol_choices=mc_tol_choices,
mc_pass_choices=mc_pass_choices,
created_by=created_by, modified_by=created_by
)
tol = models.Tolerance(**kwargs)
tol.save()
return tol
def create_test_list_instance(
unit_test_collection=None, work_completed=None, created_by=None, test_list=None, day=0, in_progress=False
):
if unit_test_collection is None:
unit_test_collection = create_unit_test_collection()
if test_list is None:
day, test_list = unit_test_collection.get_list(day)
if work_completed is None:
work_completed = timezone.now()
work_started = work_completed - timezone.timedelta(seconds=60)
if created_by is None:
created_by = create_user()
tli = models.TestListInstance(
unit_test_collection=unit_test_collection,
created_by=created_by,
modified_by=created_by,
modified=timezone.now(),
work_completed=work_completed,
work_started=work_started,
test_list=test_list,
day=day,
in_progress=in_progress
)
tli.save()
return tli
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 test_third_party_and_hours(self):
se = sl_models.ServiceEvent.objects.first()
tp = sl_utils.create_third_party()
h_01 = sl_utils.create_hours(service_event=se,
third_party=tp,
user=None)
with self.assertRaises(IntegrityError):
sl_models.Hours.objects.create(service_event=se,
third_party=tp,
user=None,
time=timezone.timedelta(hours=1))
u_02 = create_user(is_superuser=False, uname='user_02')
h_02 = sl_utils.create_hours(service_event=se, user=u_02)
# Test user_or_third_party
self.assertEqual((tp.__class__, tp.id),
(h_01.user_or_thirdparty().__class__,
h_01.user_or_thirdparty().id))
self.assertEqual((u_02.__class__, u_02.id),
(h_02.user_or_thirdparty().__class__,
h_02.user_or_thirdparty().id))
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 create_reference(name="ref", ref_type=models.NUMERICAL, value=1, created_by=None):
if created_by is None:
created_by = create_user()
r = models.Reference(
name=name, type=ref_type, value=value,
created_by=created_by, modified_by=created_by
)
r.save()
return r
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 setUp(self):
self.factory = RequestFactory()
self.user = create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
get_internal_user()
get_bool_tols() # hack to work around tolerances being deleted somewhere (in another test?)
self.site = AdminSite()
self.u_1 = qa_utils.create_unit()
self.t_1 = qa_utils.create_test(test_type=qa_models.SIMPLE)
self.t_2 = qa_utils.create_test(test_type=qa_models.BOOLEAN)
self.t_3 = qa_utils.create_test(test_type=qa_models.MULTIPLE_CHOICE)
self.t_4 = qa_utils.create_test(test_type=qa_models.SIMPLE)
self.t_5 = qa_utils.create_test(test_type=qa_models.BOOLEAN)
self.t_6 = qa_utils.create_test(test_type=qa_models.MULTIPLE_CHOICE)
self.t_360 = qa_utils.create_test(test_type=qa_models.WRAPAROUND, wrap_low=0, wrap_high=360)
self.tol_1 = qa_utils.create_tolerance()
self.tol_2 = qa_utils.create_tolerance(act_low=-10, act_high=10)
self.tol_3 = qa_models.Tolerance.objects.filter(type=qa_models.BOOLEAN).first()
self.tol_4 = qa_utils.create_tolerance(
tol_type=qa_models.MULTIPLE_CHOICE, mc_pass_choices='2,4,6', mc_tol_choices='1,3,5'
)
self.tol_5 = qa_utils.create_tolerance(tol_type=qa_models.PERCENT)
self.r_1 = qa_utils.create_reference()
self.r_2 = qa_utils.create_reference(value=1.61803)
self.r_3 = qa_utils.create_reference(ref_type=qa_models.BOOLEAN)
self.uti_1 = qa_utils.create_unit_test_info(unit=self.u_1, test=self.t_1, ref=self.r_1, tol=self.tol_1)
self.uti_2 = qa_utils.create_unit_test_info(unit=self.u_1, test=self.t_2, ref=self.r_1, tol=self.tol_1)
self.uti_3 = qa_utils.create_unit_test_info(unit=self.u_1, test=self.t_3)
self.uti_4 = qa_utils.create_unit_test_info(unit=self.u_1, test=self.t_4)
self.uti_5 = qa_utils.create_unit_test_info(unit=self.u_1, test=self.t_5, tol=self.tol_3)
self.uti_6 = qa_utils.create_unit_test_info(unit=self.u_1, test=self.t_6, tol=self.tol_4)
self.uti_360 = qa_utils.create_unit_test_info(unit=self.u_1, test=self.t_360, ref=self.r_1, tol=self.tol_1)
self.url_list = reverse(
'admin:%s_%s_changelist' % (qa_models.UnitTestInfo._meta.app_label, qa_models.UnitTestInfo._meta.model_name)
)
self.url_change = reverse(
'admin:%s_%s_change' % (qa_models.UnitTestInfo._meta.app_label, qa_models.UnitTestInfo._meta.model_name),
args=[self.uti_1.id]
)
self.data = {
'unit': self.u_1.id,
'test': self.t_1.id,
'test_type': self.t_1.type,
'reference_value': self.r_2.value,
'tolerance': self.tol_1.id,
'id': self.uti_1.id
}
def create_test_list(name=None):
if name is None:
name = 'test_list_%04d' % get_next_id(models.TestList.objects.order_by('id').last())
user = create_user()
test_list = models.TestList(
name=name,
slug=name,
description="desc",
created_by=user,
modified_by=user,
)
test_list.save()
return test_list
def setUp(self):
self.user = create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
self.url_add = reverse('admin:%s_%s_add' %
(QCCompletedNotice._meta.app_label,
QCCompletedNotice._meta.model_name))
self.url_list = reverse('admin:%s_%s_changelist' % (
QCCompletedNotice._meta.app_label,
QCCompletedNotice._meta.model_name,
))
self.admin = admin.QCCompletedAdmin(model=QCCompletedNotice,
admin_site=AdminSite())
def setUp(self):
create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
self.u = qa_utils.create_unit()
tl1 = qa_utils.create_test_list()
tl2 = qa_utils.create_test_list()
tl3 = qa_utils.create_test_list()
qa_utils.create_unit_test_collection(unit=self.u, test_collection=tl1)
qa_utils.create_unit_test_collection(unit=self.u, test_collection=tl2)
qa_utils.create_unit_test_collection(unit=self.u, test_collection=tl3)
tlc1 = qa_utils.create_cycle(test_lists=[tl1, tl2, tl3])
qa_utils.create_unit_test_collection(unit=self.u, test_collection=tlc1)
self.url_tl = reverse(
'qa_copy_refs_and_tols_testlist_json', kwargs={
'source_unit': self.u.id, 'content_type': qa_models.TestList.__name__.lower()
}
)
self.url_tlc = reverse(
'qa_copy_refs_and_tols_testlist_json', kwargs={
'source_unit': self.u.id, 'content_type': qa_models.TestListCycle.__name__.lower()
})
self.url_bad = reverse(
'qa_copy_refs_and_tols_testlist_json', kwargs={
'source_unit': self.u.id, 'content_type': qa_models.Test.__name__.lower()
}
)
self.tl_ct = ContentType.objects.get(model='testlist')
self.tlc_ct = ContentType.objects.get(model='testlistcycle')
def create_hours(service_event=None,
third_party=None,
user=None,
time=timezone.timedelta(hours=1)):
if service_event is None:
service_event = create_service_event()
if third_party is None and user is None:
user = create_user()
h, _ = models.Hours.objects.get_or_create(service_event=service_event,
third_party=third_party,
user=user,
time=time)
return h
def test_email_sent_to_group_and_single_user(self):
"""Main group is not included in notification, only new user, so only one email
should be sent to the new user"""
FaultNotice.objects.create(
notification_type=FaultNotice.LOGGED,
recipients=self.recipients,
)
user2 = create_user(uname="user2")
user2.email = "*****@*****.**"
user2.save()
self.recipients.users.add(user2)
utils.create_fault(unit=self.unit)
assert len(mail.outbox) == 1
assert list(sorted(mail.outbox[0].recipients())) == [
'*****@*****.**', '*****@*****.**'
]
def 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
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 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 test_email_not_sent_to_group_for_unit(self):
"""Main group is not included in notification, only the new group, so only one email
should be sent to the new user"""
group2 = qa_utils.create_group(name="group2")
rg = RecipientGroup.objects.create(name='group2')
rg.groups.add(group2)
FaultNotice.objects.create(
notification_type=FaultNotice.LOGGED,
recipients=rg,
units=self.unit_group,
)
user2 = create_user(uname="user2")
user2.email = "*****@*****.**"
user2.save()
user2.groups.add(group2)
utils.create_fault(unit=self.unit)
assert len(mail.outbox) == 1
assert mail.outbox[0].recipients() == ['*****@*****.**']
def create_group_linker_instance(group_linker=None,
user=None,
service_event=None,
datetime_linked=timezone.now()):
if group_linker is None:
group_linker = create_group_linker()
if user is None:
user = create_user()
if service_event is None:
service_event = create_service_event()
user.groups.add(group_linker.group)
gli, _ = models.GroupLinkerInstance.objects.get_or_create(
group_linker=group_linker,
user=user,
service_event=service_event,
datetime_linked=datetime_linked)
return gli
def setUp(self):
self.user = create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
self.c_1 = qa_utils.create_category()
self.t_1 = qa_utils.create_test()
self.tl_1 = qa_utils.create_test_list()
qa_utils.create_test_list_membership(test=self.t_1, test_list=self.tl_1)
self.tli_1 = qa_utils.create_test_list_instance(test_list=self.tl_1)
self.ti_1 = qa_utils.create_test_instance(
test_list_instance=self.tli_1, unit_test_info=qa_utils.create_unit_test_info(test=self.t_1), value=1
)
self.url_add = reverse(
'admin:%s_%s_add' % (qa_models.Test._meta.app_label, qa_models.Test._meta.model_name)
)
self.url_list = reverse(
'admin:%s_%s_changelist' % (qa_models.Test._meta.app_label, qa_models.Test._meta.model_name)
)
self.url_change = reverse(
'admin:%s_%s_change' % (qa_models.Test._meta.app_label, qa_models.Test._meta.model_name),
args=[self.t_1.id]
)
self.data = {
'procedure': '',
'category': self.c_1.id,
'attachment_set-MIN_NUM_FORMS': 0,
'attachment_set-INITIAL_FORMS': 0,
'attachment_set-MAX_NUM_FORMS': 0,
'attachment_set-TOTAL_FORMS': 0,
'chart_visibility': 'on',
'constant_value': '',
'description': '',
'slug': '',
'type': 'simple',
'calculation_procedure': '',
'choices': '',
'name': ''
}
def test_delete_hours_variables(self):
# service_event > Cascade
# third_party > Protect
# user > Protect
tp = sl_utils.create_third_party()
h = sl_utils.create_hours(third_party=tp)
se = h.service_event
h_id = h.id
with self.assertRaises(ProtectedError):
tp.delete()
se.delete()
self.assertFalse(sl_models.Hours.objects.filter(id=h_id).exists())
u = create_user()
h = sl_utils.create_hours(user=u)
with self.assertRaises(ProtectedError):
u.delete()
def setUp(self):
self.user = create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
self.t = qa_utils.create_tolerance()
self.url_add = reverse(
'admin:%s_%s_add' % (qa_models.Tolerance._meta.app_label, qa_models.Tolerance._meta.model_name)
)
self.url_list = reverse(
'admin:%s_%s_changelist' % (qa_models.Tolerance._meta.app_label, qa_models.Tolerance._meta.model_name)
)
self.data = {
'mc_tol_choices': '',
'act_low': '0',
'tol_low': '1',
'tol_high': '2',
'act_high': '3',
'type': 'absolute',
'mc_pass_choices': ''
}
def create_cycle(test_lists=None, name=None):
if name is None:
name = 'test_list_cycle_%04d' % get_next_id(models.TestListCycle.objects.order_by('id').last())
user = create_user()
cycle = models.TestListCycle(
name=name,
slug=name,
created_by=user,
modified_by=user
)
cycle.save()
if test_lists:
for order, test_list in enumerate(test_lists):
tlcm = models.TestListCycleMembership(
test_list=test_list,
cycle=cycle,
order=order
)
tlcm.save()
return cycle
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 setUp(self):
self.user = create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
self.t_1 = qa_utils.create_test()
self.t_2 = qa_utils.create_test()
self.u_1 = qa_utils.create_unit()
self.f_1 = qa_utils.create_frequency()
self.tl_1 = qa_utils.create_test_list()
self.utc_1 = qa_utils.create_unit_test_collection(test_collection=self.tl_1, unit=self.u_1)
self.utc_2 = qa_utils.create_unit_test_collection(test_collection=self.tl_1, frequency=self.f_1)
qa_utils.create_test_list_membership(test_list=self.tl_1, test=self.t_2, order=0)
self.sublist = qa_utils.create_sublist(parent_test_list=self.tl_1)
self.url_add = reverse(
'admin:%s_%s_add' % (qa_models.TestList._meta.app_label, qa_models.TestList._meta.model_name)
)
self.url_list = reverse(
'admin:%s_%s_changelist' % (qa_models.TestList._meta.app_label, qa_models.TestList._meta.model_name)
)
self.url_change = reverse(
'admin:%s_%s_change' % (qa_models.TestList._meta.app_label, qa_models.TestList._meta.model_name),
args=[self.tl_1.id]
)
self.data = {
'name': 'testing_sublists',
'warning_message': 'erroR',
'javascript': 'alert("subs!")',
'slug': 'testing_sublists',
'description': 'description',
'attachment_set-MAX_NUM_FORMS': 10,
'attachment_set-INITIAL_FORMS': 0,
'attachment_set-MIN_NUM_FORMS': 0,
'attachment_set-TOTAL_FORMS': 1,
'attachment_set-0-testlist': '',
'attachment_set-0-id': '',
'attachment_set-0-comment': 'Testing',
'attachment_set-0-attachment': '',
'children-INITIAL_FORMS': 0,
'children-MIN_NUM_FORMS': 0,
'children-MAX_NUM_FORMS': 10,
'children-TOTAL_FORMS': 1,
'children-0-order': 1,
'children-0-child': self.tl_1.id,
'children-0-parent': '',
'children-0-id': '',
'testlistmembership_set-MIN_NUM_FORMS': 0,
'testlistmembership_set-INITIAL_FORMS': 0,
'testlistmembership_set-MAX_NUM_FORMS': 10,
'testlistmembership_set-TOTAL_FORMS': 1,
'testlistmembership_set-0-test_list': '',
'testlistmembership_set-0-id': '',
'testlistmembership_set-0-order': 0,
'testlistmembership_set-0-test': self.t_1.id
}
def setUp(self):
self.password = '******'
self.user = create_user(pwd=self.password)
