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 test_queryset_no(self):
utils.create_user(uname="admin", is_staff=True, is_superuser=True)
utils.create_user(uname="reg", is_staff=False, is_superuser=False)
af = AdminFilter(None, [], None, None)
af.value = lambda: 'no'
assert af.queryset(
None, User.objects.all()).count() == 1 + 1 # count Internal User
def setUp(self):
utils.create_user(is_superuser=True, uname='user', pwd='pwd')
self.client.login(username='******', password='******')
self.get_url = reverse('unit_available_time')
self.post_url = reverse('handle_unit_available_time')
self.delete_url = reverse('delete_schedules')
utils.create_unit()
utils.create_unit()
utils.create_unit()
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 setUp(self):
self.factory = RequestFactory()
self.view = p_views.PartUpdateCreate.as_view()
self.url = reverse('part_new')
self.user = qa_utils.create_user(is_superuser=True)
self.client.login(username='******', password='******')
self.pc = sl_utils.create_part_category()
self.sup = sl_utils.create_supplier()
self.sto = sl_utils.create_storage()
self.data = {
'part_number': 'p001',
'new_or_used': 'both',
'cost': '1',
'quantity_min': 0,
'name': 'description',
'alt_part_number': 'alt-num',
'part_category': self.pc.id,
'notes': 'This is a part',
'is_obsolete': 0,
'storage-MAX_NUM_FORMS': 1000,
'storage-MIN_NUM_FORMS': 0,
'storage-TOTAL_FORMS': 0,
'storage-INITIAL_FORMS': 0,
'supplier-MAX_NUM_FORMS': 1000,
'supplier-MIN_NUM_FORMS': 0,
'supplier-TOTAL_FORMS': 0,
'supplier-INITIAL_FORMS': 0,
}
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 create_service_event_template(name=None,
service_type=None,
service_area=None,
problem_description="",
work_description="",
created_by=None):
if name is None:
name = 'name_%04d' % get_next_id(
models.ServiceEventTemplate.objects.order_by('id').last())
if created_by is None:
created_by = qa_utils.create_user()
template, _ = models.ServiceEventTemplate.objects.get_or_create(
name=name,
service_area=service_area,
service_type=service_type,
problem_description=problem_description,
work_description=work_description,
created_by=created_by,
modified_by=created_by,
)
return template
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.url = reverse("fault_type_autocomplete")
user = User.objects.create_superuser("faultuser", "*****@*****.**",
"password")
self.client.force_login(user)
def test_with_review_groups_with_perm(self):
frg = utils.create_fault_review_group()
user = qa_utils.create_user()
p = Permission.objects.get(name="Can review faults")
user.user_permissions.add(p)
user.groups.add(frg.group)
assert can_review_faults(user)
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")
u_models.Modality.objects.all().delete()
self.modality = qa_utils.create_modality(name="modality")
self.adm = admin.FaultAdmin(Fault, AdminSite())
self.mf = admin.ModalityFilter(mock.Mock(), {}, Fault, self.adm)
def test_existing_created_user_not_overwritten(self):
user2 = utils.create_user(uname="user2")
pack = testpack.create_testpack(self.tlqs, self.tlcqs)
fp = io.StringIO()
testpack.save_testpack(pack, fp)
fp.seek(0)
testpack.load_testpack(fp, user2)
assert models.TestList.objects.get(
slug=self.tl1.slug).created_by != user2
def setUp(self):
self.factory = RequestFactory()
self.user = qa_utils.create_user(is_superuser=True)
self.client.login(username='******', password='******')
sl_utils.create_part(part_number='find_1', add_storage=True)
sl_utils.create_part(part_number='find_2', add_storage=True)
sl_utils.create_part(part_number='find_3', add_storage=True)
sl_utils.create_part(name='a part to find', add_storage=True)
sl_utils.create_part(name='a part to find', add_storage=True)
def test_password_reset(self):
"""Test full cycle of password reset process"""
Site.objects.all().update(domain="")
u = utils.create_user()
self.client.post(reverse("password_reset"), {'email': u.email})
assert "Password reset" in mail.outbox[0].subject
url = re.search(r"(?P<url>https?://[^\s]+)",
mail.outbox[0].body).group("url")
resp = self.client.get(url)
resp = self.client.post(resp.url, {
'new_password1': '8P0Cut!v6XUr',
'new_password2': '8P0Cut!v6XUr',
},
follow=True)
assert "/accounts/reset/done/" in resp.redirect_chain[0]
def setUp(self):
self.user = qa_utils.create_user(is_superuser=True)
self.client.login(username='******', password='******')
self.url_add = reverse('admin:%s_%s_add' %
(models.ServiceEventStatus._meta.app_label,
models.ServiceEventStatus._meta.model_name))
self.data = {
'name': 'status_name',
'is_default': True,
'is_review_required': False,
'rts_must_be_reviewed': False,
'colour': settings.DEFAULT_COLOURS[0],
'description': 'test description',
'order': 0,
}
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"""
QCCompletedNotice.objects.create(
notification_type=QCCompletedNotice.TOLERANCE,
recipients=self.recipients,
)
user2 = utils.create_user(uname="user2")
user2.email = "*****@*****.**"
user2.save()
self.recipients.users.add(user2)
signals.testlist_complete.send(sender=self,
instance=self.test_list_instance,
created=True)
assert len(mail.outbox) == 1
assert list(sorted(mail.outbox[0].recipients())) == [
'*****@*****.**', '*****@*****.**'
]
def setUp(self):
self.user = utils.create_user()
self.tl1 = utils.create_test_list("tl1 é")
self.tl2 = utils.create_test_list("tl2")
self.tl3 = utils.create_test_list("tl3")
self.tlc = utils.create_cycle([self.tl1, self.tl2])
self.t1 = utils.create_test("t1")
self.t2 = utils.create_test("t2")
self.t3 = utils.create_test("t3")
self.t4 = utils.create_test("t4")
utils.create_test_list_membership(self.tl1, self.t1)
utils.create_test_list_membership(self.tl2, self.t2)
utils.create_test_list_membership(self.tl3, self.t3)
utils.create_test_list_membership(self.tl3, self.t1)
self.tlqs = models.TestList.objects.filter(pk=self.tl3.pk)
self.tlcqs = models.TestListCycle.objects.filter(pk=self.tlc.pk)
self.extra = models.Test.objects.filter(pk=self.t4.pk)
def test_edit_with_changed_reviews(self):
"""Test that editing a fault with existing reviewer works"""
FaultType.objects.create(code="fault type")
fault = utils.create_fault(user=self.user)
rev_group = utils.create_fault_review_group()
utils.create_fault_review(fault=fault,
review_group=rev_group,
reviewed_by=self.user)
self.user.groups.add(rev_group.group)
new_u = qa_utils.create_user()
new_u.groups.add(rev_group.group)
modality = u_models.Modality.objects.create(name="modality")
fault.unit.modalities.add(modality)
edit_url = reverse("fault_edit", kwargs={'pk': fault.pk})
se = sl_utils.create_service_event()
fault.related_service_events.add(se)
data = {
"fault-occurred": format_datetime(fault.occurred),
"fault-unit": fault.unit.id,
"fault-modality": modality.pk,
"fault-fault_types_field": [fault.fault_types.first().code],
"fault-comment": "",
"fault-related_service_events": [se.pk],
"review-form-0-group": rev_group.group.name,
"review-form-0-reviewed_by": new_u.pk,
}
assert list(
fault.faultreviewinstance_set.values_list(
"reviewed_by_id", flat=True)) == [self.user.pk]
resp = self.client.post(edit_url, data)
assert resp.status_code == 302
fault.refresh_from_db()
assert fault.faultreviewinstance_set.count() == 1
assert list(
fault.faultreviewinstance_set.values_list(
"reviewed_by_id", flat=True)) == [new_u.pk]
def create_fault_review(fault=None,
review_group=None,
reviewed_by=None,
reviewed=None):
reviewed = reviewed or timezone.now()
if review_group is False:
review_group = None
elif review_group is None:
review_group = create_fault_review_group()
fault = fault or create_fault()
reviewed_by = reviewed_by or qa_utils.create_user()
return models.FaultReviewInstance.objects.create(
reviewed=reviewed,
reviewed_by=reviewed_by,
fault=fault,
fault_review_group=review_group,
)
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 = utils.create_group(name="group2")
rg = RecipientGroup.objects.create(name='group2')
rg.groups.add(group2)
QCCompletedNotice.objects.create(
notification_type=QCCompletedNotice.TOLERANCE,
recipients=rg,
units=self.unit_group,
)
user2 = utils.create_user(uname="user2")
user2.email = "*****@*****.**"
user2.save()
user2.groups.add(group2)
signals.testlist_complete.send(sender=self,
instance=self.test_list_instance,
created=True)
assert len(mail.outbox) == 1
assert mail.outbox[0].recipients() == ['*****@*****.**']
def test_no_review_groups(self):
user = qa_utils.create_user()
p = Permission.objects.get(name="Can review faults")
user.user_permissions.add(p)
assert can_review_faults(user)
def test_with_review_groups_no_perm(self):
utils.create_fault_review_group()
user = qa_utils.create_user()
assert not can_review_faults(user)
def setUp(self):
self.user = qa_utils.create_user()
self.unit = qa_utils.create_unit()
user = User.objects.create_superuser("faultuser", "*****@*****.**",
"password")
self.client.force_login(user)
def setUp(self):
self.user = qa_utils.create_user()
self.fault_type = FaultType.objects.create(code="ABC", slug="abc")
