def test_pre_order_with_aliquot(self):
""" Link pre order to aliquot"""
PreOrder.objects.all().delete()
self.subject_visit_male_T0 = self.baseline_subject_visit
self._hiv_result = self.hiv_result(NEG, self.subject_visit_male_T0)
self.assertEqual(PreOrder.objects.all().count(), 1)
self.assertEqual(PreOrder.objects.first().status, NEW)
requisition = SubjectRequisition.objects.get(panel__name='Microtube')
requisition.is_receive = True
requisition.is_receive_datetime = datetime.now()
requisition.save()
lab_profile = site_lab_profiles.get('SubjectRequisition')
lab_profile().receive(
SubjectRequisition.objects.get(panel__name='Microtube'))
self.assertEqual(Receive.objects.all().count(), 1)
self.assertEqual(Aliquot.objects.all().count(), 1)
ProcessingFactory(aliquot=Aliquot.objects.first(),
profile=AliquotProfile.objects.get(name='Microtube'))
pre_order = PreOrder.objects.first()
pre_order.aliquot_identifier = Aliquot.objects.get(
aliquot_type__alpha_code='PL').aliquot_identifier
pre_order.save()
self.assertEqual(PreOrder.objects.first().status, CLOSED)
pre_order.aliquot_identifier = Aliquot.objects.get(
aliquot_type__alpha_code='PL').aliquot_identifier + 'x'
with self.assertRaises(ValidationError):
pre_order.save()
def test_use_aliquot_that_belongs_to_subject(self):
""" Attempt to link multiple pre order records to the same aliquot identifier"""
PreOrder.objects.all().delete()
self.subject_visit_male_T0 = self.baseline_subject_visit
self._hiv_result = self.hiv_result(NEG, self.subject_visit_male_T0)
self.assertEqual(PreOrder.objects.all().count(), 1)
male_preorder = PreOrder.objects.all()[0]
self._hiv_result = self.hiv_result(NEG, self.subject_visit_female_T0)
self.assertEqual(PreOrder.objects.all().count(), 2)
# Process the female's Aliquots.
lab_profile = site_lab_profiles.get('SubjectRequisition')
lab_profile().receive(
SubjectRequisition.objects.get(
subject_visit=self.subject_visit_female_T0,
panel__name='Microtube'))
self.assertEqual(Receive.objects.all().count(), 1)
self.assertEqual(Aliquot.objects.all().count(), 1)
ProcessingFactory(aliquot=Aliquot.objects.first(),
profile=AliquotProfile.objects.get(name='Microtube'))
# Attempt to save the male_preorder using a female's aliquot
male_preorder.aliquot_identifier = Aliquot.objects.first(
).aliquot_identifier
with self.assertRaises(ValidationError):
male_preorder.save()
def test_create_aliquot_on_receive(self):
"""Asserts packing list items are created by the packing list."""
self.startup()
report_datetime = datetime.today()
panel = Panel.objects.get(name='Microtube')
subject_requisition = SubjectRequisitionFactory(
subject_visit=self.subject_visit_male_annual,
site=self.study_site,
panel=panel,
aliquot_type=AliquotType.objects.get(alpha_code='WB'))
subject_referral = SubjectReferralFactory(
subject_visit=self.subject_visit_male_annual,
report_datetime=report_datetime)
# receive
lab_profile = site_lab_profiles.get(
subject_requisition._meta.object_name)
receive = lab_profile().receive(subject_requisition)
identifiers = '\n'.join([
a.aliquot_identifier
for a in Aliquot.objects.filter(receive=receive)
])
packing_list = PackingListFactory(list_items=identifiers)
self.assertGreater(PackingListItem.objects.all().count(), 0)
for identifier in identifiers:
self.assertEquals(
PackingListItem.objects.get(packing_list=packing_list,
item_reference=identifier))
packing_list = PackingListFactory(list_items=identifiers)
for identifier in identifiers:
self.assertEquals(
PackingListItem.objects.get(packing_list=packing_list,
item_reference=identifier))
def flag_as_received(modeladmin, request, queryset, **kwargs):
""" Flags specimen(s) as received and generates a globally specimen identifier and updates lab_clinic_api."""
for qs in queryset:
try:
receive = None
lab_profile = site_lab_profiles.get(qs._meta.object_name)
receive = lab_profile().receive(qs)
msg = 'Received {} as {}'.format(
qs.requisition_identifier, receive.receive_identifier)
try:
messages.add_message(request, messages.SUCCESS, msg)
except MessageFailure: # except to get past testing with request=None
print msg
except SpecimenError as e:
try:
messages.add_message(request, messages.ERROR, str(e))
except MessageFailure: # except to get past testing with request=None
print msg
break
def test_create_aliquot_on_receive(self):
"""Asserts a primary aliquot is created on receiving a requisition."""
self.startup()
report_datetime = datetime.today()
panel = Panel.objects.get(name='Microtube')
subject_requisition = SubjectRequisitionFactory(
subject_visit=self.subject_visit_male,
site=self.study_site,
panel=panel,
aliquot_type=AliquotType.objects.get(alpha_code='WB'))
# receive
lab_profile = site_lab_profiles.get(
subject_requisition._meta.object_name)
receive = lab_profile().receive(subject_requisition)
# assert primary aliquot
try:
Aliquot.objects.get(receive=receive)
except Aliquot.DoesNotExist as e:
self.fail(str(e))
def test_attempt_to_link_multiple_preorder_to_same_aliquot(self):
""" Attempt to link multiple pre order records to the same aliquot identifier"""
PreOrder.objects.all().delete()
self.subject_visit_male_T0 = self.baseline_subject_visit
self._hiv_result = self.hiv_result(POS, self.subject_visit_male_T0)
aliquot_type = AliquotType.objects.all()[0]
viral_load_panel = Panel.objects.get(name='Viral Load')
PreOrder.objects.all().delete()
HivCareAdherence.objects.create(
subject_visit=self.subject_visit_male_T0,
first_positive=None,
medical_care=NO,
ever_recommended_arv=NO,
ever_taken_arv=NO,
on_arv=NO,
arv_evidence=NO,
)
SubjectRequisitionFactory(subject_visit=self.subject_visit_male_T0,
panel=viral_load_panel,
aliquot_type=aliquot_type,
site=self.study_site)
self.assertEqual(PreOrder.objects.all().count(), 2)
self.assertEqual(PreOrder.objects.first().status, NEW)
pre_order1 = PreOrder.objects.all()[0]
pre_order2 = PreOrder.objects.all()[1]
# Process the primary aliquot
lab_profile = site_lab_profiles.get('SubjectRequisition')
lab_profile().receive(
SubjectRequisition.objects.get(panel__name='Viral Load'))
self.assertEqual(Receive.objects.all().count(), 1)
self.assertEqual(Aliquot.objects.all().count(), 1)
ProcessingFactory(
aliquot=Aliquot.objects.first(),
profile=AliquotProfile.objects.get(name='Viral Load'))
pre_order1.aliquot_identifier = Aliquot.objects.filter(
aliquot_type__alpha_code='PL').first().aliquot_identifier
pre_order2.aliquot_identifier = pre_order1.aliquot_identifier
pre_order1.save()
with self.assertRaises(ValidationError):
pre_order2.save()
def test_p3(self):
instances = []
plot = PlotFactory(community='test_community6',
household_count=1,
status='residential_habitable')
household = Household.objects.get(plot=plot)
household_structure = HouseholdStructure.objects.get(
survey=Survey.objects.all()[0])
representative_eligibility = RepresentativeEligibilityFactory(
household_structure=household_structure)
household_member = HouseholdMemberFactory(
household_structure=household_structure)
enrollment_checklist = EnrollmentChecklistFactory(
household_member=household_member,
initials=household_member.initials,
has_identity='Yes',
dob=date(1989, 01, 01))
self.assertTrue(enrollment_checklist.is_eligible)
instances.append(enrollment_checklist)
self.assertEqual(RegisteredSubject.objects.all().count(), 1)
registered_subject = RegisteredSubject.objects.all()[0]
site = StudySite.objects.all()[0]
subject_consent = SubjectConsentFactory(
study_site=site,
household_member=household_member,
registered_subject=household_member.registered_subject,
dob=enrollment_checklist.dob,
initials=enrollment_checklist.initials)
instances.append(subject_consent)
self.assertEqual(Appointment.objects.all().count(), 1)
appointment = Appointment.objects.get(
registered_subject=registered_subject)
subject_visit = SubjectVisitFactory(household_member=household_member,
appointment=appointment)
instances.append(subject_visit)
aliquot_type = AliquotType.objects.all()[0]
panel = Panel.objects.all()[0]
subjects_requisition = SubjectRequisitionFactory(
subject_visit=subject_visit,
panel=panel,
site=site,
aliquot_type=aliquot_type,
)
self.assertEqual(Aliquot.objects.all().count(), 0)
subjects_requisition.is_receive = True
subjects_requisition.is_receive_datetime = datetime.now()
subjects_requisition.save()
lab_profile = site_lab_profiles.get(
subjects_requisition._meta.object_name)
lab_profile().receive(subjects_requisition)
receive = Receive.objects.all()[0]
self.assertEqual(Aliquot.objects.all().count(), 1)
aliquot = Aliquot.objects.all()[0]
processing = ProcessingFactory(profile=AliquotProfile.objects.all()[0],
aliquot=aliquot)
for al in Aliquot.objects.all():
instances.append(al)
instances.append(processing)
instances.append(receive)
self.assertEqual(PackingListItem.objects.all().count(), 0)
packing_list = PackingListFactory(
list_items=aliquot.aliquot_identifier)
instances.append(packing_list)
packing_list.list_items = al.aliquot_identifier
print packing_list.list_items
packing_list.save()
#self.assertEquals(PackingListItem.objects.all().count(), 1)
#instances.append(PackingListItem.objects.all()[0])
print 'INSTANCE: ' + str(instances)
for obj in instances:
print 'test natural key on {0}'.format(obj._meta.object_name)
natural_key = obj.natural_key()
get_obj = obj.__class__.objects.get_by_natural_key(*natural_key)
self.assertEqual(obj.pk, get_obj.pk)
# pp = pprint.PrettyPrinter(indent=4)
for obj in instances:
print 'test serializing/deserializing {0}'.format(
obj._meta.object_name)
outgoing_transaction = SerializeToTransaction().serialize(
obj.__class__, obj, False, True, 'default')
for transaction in serializers.deserialize(
"json",
FieldCryptor('aes',
'local').decrypt(outgoing_transaction.tx)):
self.assertEqual(transaction.object.pk, obj.pk)