def test_lab_add_view_with_perm(self):
"""User with lab permissions is able to add lab"""
log_in_user(self.client,
build_user([user_factories.CaseManagerGroupFactory]))
assert ContinuousMeasurement.objects.count() == 2
assert DiscreteMeasurement.objects.count() == 1
assert Lab.objects.count() == 1
url = reverse('labs:new-lab', kwargs={'pt_id': self.pt.id})
response = self.client.get(url)
response = self.client.post(url, self.submitted_form_step1)
assert response.status_code == 302
# Successfully redirect to step 2 view
url = reverse('labs:new-full-lab',
kwargs={
'pt_id': self.pt.id,
'lab_type_id': self.ua.id
})
assert response.url == url
response = self.client.post(url, self.submitted_form_step2)
assert response.status_code == 302
# Successfully added lab and measurement objects
assert ContinuousMeasurement.objects.count() == 4
assert DiscreteMeasurement.objects.count() == 2
assert Lab.objects.count() == 2
# Successfully redirect back to table view
url = reverse("labs:all-labs-table", kwargs={'pt_id': self.pt.id})
assert response.url == url
def test_workup_update(self):
'''
Updating should be possible always for attendings, only without
attestation for non-attendings.
'''
# if the wu is unsigned, all can access update.
for role in user_factories.all_roles:
log_in_user(self.client, build_user([role]))
response = self.client.get(
reverse('workup-update', args=(self.wu.id, )))
assert response.status_code == 200
signer = build_user([user_factories.AttendingGroupFactory])
self.wu.sign(signer, signer.groups.first())
self.wu.save()
# nonattesting cannot access while attesting can
for role in user_factories.all_roles:
log_in_user(self.client, build_user([role]))
response = self.client.get(
reverse('workup-update', args=(self.wu.id, )))
if role in user_factories.attesting_roles:
assert response.status_code == 200
else:
self.assertRedirects(response,
reverse('workup', args=(self.wu.id, )))
def setUp(self):
self.user = build_user()
log_in_user(self.client, self.user)
self.contact_method = ContactMethod.objects.create(
name="Carrier Pidgeon")
self.contact_result = ContactResult.objects.create(
name="Reached on phone", patient_reached=True)
self.pt = Patient.objects.create(
first_name="Juggie",
last_name="Brodeltein",
middle_name="Bayer",
phone='+49 178 236 5288',
gender=Gender.objects.first(),
address='Schulstrasse 9',
city='Munich',
state='BA',
zip_code='63108',
pcp_preferred_zip='63018',
date_of_birth=datetime.date(1990, 1, 1),
patient_comfortable_with_english=False,
preferred_contact_method=self.contact_method,
)
self.reftype = ReferralType.objects.create(
name="Specialty", is_fqhc=False)
self.refloc = ReferralLocation.objects.create(
name='COH', address='Euclid Ave.')
self.refloc.care_availiable.add(self.reftype)
self.no_show_reason = NoShowReason.objects.create(name="Hella busy.")
def test_AttestableBasicNote_signing(self):
"""Verify that signing is possible for those with relevant permission.
"""
sign_url = "attestable-basic-note-sign"
note = models.AttestableBasicNote.objects.create(**self.note_data)
# Fresh notes should be unsigned
assert not note.signed()
# Providers with can_attend == False should not be able to sign
can_sign_group = user_factories.PermGroupFactory(
permissions=['workup.sign_AttestableBasicNote'])
cannot_sign_group = user_factories.NoPermGroupFactory()
can_sign = user_factories.UserFactory(groups=[can_sign_group])
cannot_sign = user_factories.UserFactory(groups=[cannot_sign_group])
for user in [can_sign, cannot_sign]:
log_in_user(self.client, user)
response = self.client.get(reverse(sign_url, args=(note.id, )))
detail_url = reverse('attestable-basic-note-detail',
args=(note.id, ))
self.assertRedirects(response, detail_url)
assert models.AttestableBasicNote.objects.get(
pk=note.id).signed() == (user == can_sign)
note.signer = None
note.save()
def setUp(self):
self.user = build_user()
log_in_user(self.client, self.user)
self.unit = factories.MeasuringUnitFactory(name='different_unit')
self.category = factories.DrugCategoryFactory(name='different_category')
self.manufacturer = factories.ManufacturerFactory(name='different_manufacturer')
self.diff_drug = {
'name': 'Differentdrug',
'unit': self.unit.pk,
'dose': 500.0,
'stock': 5,
'expiration_date': '2100-01-01',
'lot_number': 'HGFEDCBA',
'category': self.category.pk,
'manufacturer': self.manufacturer.pk
}
self.drug = factories.DrugFactory()
self.pt = core_factories.PatientFactory()
self.encounter = core_factories.EncounterFactory(patient=self.pt)
def test_workup_submit(self):
"""verify we can submit a valid workup as a signer and nonsigner"""
for role in user_factories.all_roles:
user = build_user([role])
log_in_user(self.client, user)
wu_count = models.Workup.objects.all().count()
wu_data = wu_dict(units=True, dx_category=True)
pt = wu_data['patient']
wu_data['patient'] = pt.id
wu_data['author'] = user.id
wu_data['author_type'] = user.groups.first().id
e = wu_data['encounter']
wu_data['encounter'] = e.id
response = self.client.post(reverse('new-workup', args=(pt.id, )),
data=wu_data)
self.assertRedirects(
response, reverse("core:patient-detail", args=(pt.id, )))
can_attest = role in user_factories.attesting_roles
assert models.Workup.objects.all().count() == wu_count + 1
new = models.Workup.objects.get(patient=pt)
assert new.signed() == can_attest
def setUp(self):
self.ua = factories.LabTypeFactory(name='Urinalysis')
self.ua_pH = factories.ContinuousMeasurementTypeFactory(
long_name='Urine pH', short_name='pH', lab_type=self.ua)
self.ua_glucose = factories.ContinuousMeasurementTypeFactory(
long_name='Urine glucose', short_name='glucose', lab_type=self.ua)
self.ua_blood = factories.DiscreteMeasurementTypeFactory(
long_name='Urine blood', short_name='blood', lab_type=self.ua)
self.disc_result_neg = factories.DiscreteResultTypeFactory(name='neg')
self.disc_result_neg.measurement_type.set([self.ua_blood])
self.pt = core_factories.PatientFactory()
self.lab = factories.LabFactory(patient=self.pt, lab_type=self.ua)
lab_ua_pH = factories.ContinuousMeasurementFactory(
measurement_type=self.ua_pH, lab=self.lab)
lab_ua_glucose = factories.ContinuousMeasurementFactory(
measurement_type=self.ua_glucose, lab=self.lab)
lab_ua_blood = factories.DiscreteMeasurementFactory(
measurement_type=self.ua_blood, lab=self.lab)
log_in_user(self.client, build_user())
self.submitted_form_step1 = {"lab_type": self.ua.id}
self.submitted_form_step2 = {
'lab_time': now().strftime("%Y-%m-%d %H:%M:%S"),
'pH': '5',
'glucose': '1',
'blood': self.disc_result_neg.name
}
def setUp(self):
self.user = build_user()
log_in_user(self.client, self.user)
self.pt = core_factories.PatientFactory(case_managers=[self.user])
self.series_type = factories.VaccineSeriesTypeFactory()
def test_lab_add_view_no_perm(self):
"""User without lab permissions can't add lab"""
log_in_user(self.client,
build_user([user_factories.NoPermGroupFactory]))
url = reverse('labs:new-lab', kwargs={'pt_id': self.pt.id})
response = self.client.get(url, follow=True)
assert response.status_code == 403
def setUp(self):
self.user = build_user()
log_in_user(self.client, self.user)
self.note_data = note_dict(user=self.user)
self.wu = models.Workup.objects.create(**wu_dict(user=self.user))
self.form_data = note_dict(user=self.user, encounter_pk=False)
def test_lab_edit_view_no_perm(self):
"""User without lab permissions can't edit lab"""
log_in_user(self.client,
build_user([user_factories.NoPermGroupFactory]))
lab = self.lab
url = reverse('labs:lab-edit', kwargs={'pk': lab.id})
response = self.client.get(url, follow=True)
assert response.status_code == 403
def setUp(self):
self.user = build_user([user_factories.AttendingGroupFactory])
log_in_user(self.client, self.user)
models.ClinicType.objects.create(name="Basic Care Clinic")
models.ClinicDate.objects.create(
clinic_type=models.ClinicType.objects.first(),
clinic_date=now().date())
def setUp(self):
log_in_user(self.client, build_user())
models.IncomeRange.objects.create(name="Default")
models.EducationLevel.objects.create(name="Default")
models.WorkStatus.objects.create(name="Default")
models.ResourceAccess.objects.create(name="Default")
models.ChronicCondition.objects.create(name="Default")
models.TransportationOption.objects.create(name="Default")
def setUp(self):
self.user = build_user()
log_in_user(self.client, self.user)
self.note_data = note_dict(user=self.user)
models.ClinicDate.objects.create(
clinic_type=models.ClinicType.objects.first(),
clinic_date=now().date())
def setUp(self):
models.ClinicDate.objects.create(
clinic_type=models.ClinicType.objects.first(),
clinic_date=now().date())
self.user = build_user()
log_in_user(self.client, self.user)
self.wu = models.Workup.objects.create(**wu_dict(user=self.user))
def setUp(self):
# build an attending and a clinical student
self.attending = build_user([user_factories.AttendingGroupFactory])
self.clinical_student = build_user()
log_in_user(self.client, self.attending)
self.wu_info = dict(chief_complaint="SOB",
diagnosis="MI",
hpi="A",
pmh="B",
psh="W",
meds="C",
allergies="D",
fam_hx="E",
soc_hx="F",
ros="",
pe="",
a_and_p="")
# prepare a patient with an unsigned wu today, in addition to
# what comes in in the fixture
self.pt2 = Patient.objects.create(
first_name="Arthur",
last_name="Miller",
middle_name="",
phone='+49 178 236 5288',
gender=Gender.objects.first(),
address='Schulstrasse 9',
city='Munich',
state='BA',
zip_code='63108',
pcp_preferred_zip='63018',
date_of_birth=datetime.date(1994, 1, 22),
patient_comfortable_with_english=False,
preferred_contact_method=ContactMethod.objects.first(),
)
EncounterStatus.objects.create(name="Active", is_active=True)
self.encounter_info = dict(clinic_day=now().date(),
status=EncounterStatus.objects.first())
Encounter.objects.create(patient=Patient.objects.first(),
**self.encounter_info)
self.wu2 = Workup.objects.create(
encounter=Encounter.objects.create(patient=self.pt2,
**self.encounter_info),
author=self.clinical_student,
author_type=self.clinical_student.groups.first(),
patient=self.pt2,
**self.wu_info)
def setUp(self):
self.user = build_user()
log_in_user(self.client, self.user)
self.ai = ActionItem.objects.create(
due_date=datetime.date(2020, 1, 1),
author=self.user,
instruction=ActionInstruction.objects.create(
instruction="Follow up on labs"),
comments="I hate tests",
author_type=self.user.groups.first(),
patient=Patient.objects.all()[0])
def setUp(self):
self.user = build_user()
log_in_user(self.client, self.user)
self.apt = models.Appointment.objects.create(
comment='test this stuff',
clindate=now().date(),
clintime=time(9, 0),
appointment_type='PSYCH_NIGHT',
author=self.user,
author_type=self.user.groups.first(),
patient=Patient.objects.first())
def setUp(self):
self.user = build_user()
log_in_user(self.client, self.user)
self.pt = core_factories.PatientFactory(case_managers=[self.user])
self.series_type = factories.VaccineSeriesTypeFactory()
self.series = factories.VaccineSeriesFactory(
author=self.user,
author_type=self.user.groups.first(),
patient=self.pt,
kind=self.series_type)
def test_export_dispensing_histories(self):
export_dispensing_histories_url = reverse('inventory:export-dispensing-history')
no_perm_group = user_factories.NoPermGroupFactory()
csv_perm_group = user_factories.PermGroupFactory(permissions=['inventory.export_csv'])
for group in [no_perm_group, csv_perm_group]:
log_in_user(self.client, user_factories.UserFactory(groups=[group]))
response = self.client.post(export_dispensing_histories_url, {'start_date': '2020-09-22','end_date': '2020-09-28'})
if group == csv_perm_group:
assert response.status_code == 200
self.assertEqual(response["Content-Disposition"],
f"attachment; filename=drug-dispensing-history-through-09/28/20.csv")
else:
assert response.status_code == 403
def setUp(self):
log_in_user(self.client, build_user())
self.drug = factories.DrugFactory()
self.drug_field = {
'name': self.drug.name,
'unit': self.drug.unit.pk,
'dose': self.drug.dose,
'stock': self.drug.stock,
'expiration_date': self.drug.expiration_date,
'lot_number': self.drug.lot_number,
'category': self.drug.category.pk,
'manufacturer': self.drug.manufacturer.pk
}
def test_workup_pdf(self):
"""Verify that pdf download with the correct name
"""
wu_url = "workup-pdf"
no_perm_group = user_factories.NoPermGroupFactory()
pdf_perm_group = user_factories.PermGroupFactory(
permissions=['workup.export_pdf_Workup'])
for group in [no_perm_group, pdf_perm_group]:
log_in_user(self.client,
user_factories.UserFactory(groups=[group]))
response = self.client.get(reverse(wu_url, args=(self.wu.id, )))
assert response.status_code == 200 if group == pdf_perm_group else 403
def test_export_csv(self):
export_csv_url = reverse('inventory:export-csv')
no_perm_group = user_factories.NoPermGroupFactory()
csv_perm_group = user_factories.PermGroupFactory(permissions=['inventory.export_csv'])
for group in [no_perm_group, csv_perm_group]:
log_in_user(self.client, user_factories.UserFactory(groups=[group]))
response = self.client.post(export_csv_url)
if group == csv_perm_group:
assert response.status_code == 200
date_list = str(timezone.now().date()).split("-")
formatted_date = f"{date_list[1]}/{date_list[2]}/{date_list[0][:2]}"
self.assertEqual(response["Content-Disposition"],
f"attachment; filename=drug-inventory-{formatted_date}.csv")
else:
assert response.status_code == 403
def test_no_create_on_view_if_USER_IP_is_in_BLACKLIST(self):
expected_user = log_in_user(self.client, build_user())
# format is: {X-Forwarded-For: client, proxy1, proxy2}
USER_IP = '0.0.0.1'
self.client.get(reverse('home'), HTTP_X_FORWARDED_FOR=USER_IP + ',,')
n_records = PageviewRecord.objects.count()
self.assertEqual(n_records, 0)
def test_workup_submit(self):
"""verify we can submit a valid workup as a signer and nonsigner"""
for role in user_factories.all_roles:
user = build_user([role])
log_in_user(self.client, user)
pt_id = Patient.objects.first().pk
wu_count = models.Workup.objects.all().count()
wu_data = wu_dict(units=True, clinic_day_pk=True, dx_category=True)
response = self.client.post(reverse('new-workup', args=(pt_id, )),
data=wu_data)
self.assertRedirects(
response, reverse("core:patient-detail", args=(pt_id, )))
can_attest = role in user_factories.attesting_roles
assert models.Workup.objects.all().count() == wu_count + 1
assert models.Workup.objects.last().signed() == can_attest
def setUp(self):
self.coordinator = build_user([user_factories.CaseManagerGroupFactory])
log_in_user(self.client, self.coordinator)
self.pt1 = core_factories.PatientFactory()
self.pt2 = core_factories.PatientFactory()
self.pt3 = core_factories.PatientFactory()
#pt1 has an active encounter today
self.encounter1 = core_factories.EncounterFactory(patient=self.pt1)
self.encounter1.order = 1
#pt2 has an active encounter today
self.encounter2 = core_factories.EncounterFactory(patient=self.pt2)
self.encounter2.order = 2
#pt3 has an inactive encounter today
self.encounter3 = core_factories.EncounterFactory(
patient=self.pt3,
status=core_factories.EncounterStatusFactory(name="Nope",
is_active=False))
self.encounter3.order = 3
def test_workup_signing(self):
"""Verify that signing is possible for attendings, and not for others.
"""
wu_url = "workup-sign"
# only attesting roles should be able to sign
for role in user_factories.attesting_roles:
assert not self.wu.signed()
log_in_user(self.client, build_user([role]))
response = self.client.get(reverse(wu_url, args=(self.wu.id, )))
self.assertRedirects(
response,
reverse('workup', args=(self.wu.id, )),
)
is_attesting = role in user_factories.attesting_roles
assert models.Workup.objects.get(
pk=self.wu.id).signed() == is_attesting
self.wu.signer = None
self.wu.save()
def setUp(self):
log_in_user(self.client, build_user())
self.contact_method = ContactMethod.objects.create(
name="Carrier Pidgeon")
self.pt = Patient.objects.create(
first_name="Juggie",
last_name="Brodeltein",
middle_name="Bayer",
phone='+49 178 236 5288',
gender=Gender.objects.first(),
address='Schulstrasse 9',
city='Munich',
state='BA',
zip_code='63108',
pcp_preferred_zip='63018',
date_of_birth=datetime.date(1990, 1, 1),
patient_comfortable_with_english=False,
preferred_contact_method=self.contact_method,
)
def test_lab_edit_view_with_perm(self):
"""User with lab permissions is able to edit lab"""
log_in_user(self.client,
build_user([user_factories.CaseManagerGroupFactory]))
lab = self.lab
assert Lab.objects.count() == 1
url = reverse('labs:lab-edit', kwargs={'pk': lab.id})
response = self.client.get(url)
response = self.client.post(url, self.submitted_form_step2)
assert response.status_code == 302
# Successfully redirect back to detail view
url = reverse("labs:lab-detail", kwargs={'pk': lab.id})
assert response.url == url
# Successfully edited measurement values without creating a new lab object
assert Lab.objects.count() == 1
assert int(
ContinuousMeasurement.objects.filter(
measurement_type=self.ua_pH).last().value) == int(
self.submitted_form_step2['pH'])
def setUp(self):
self.user = build_user()
log_in_user(self.client, self.user)
self.pt = core_factories.PatientFactory(case_managers=[self.user])
self.series_type = factories.VaccineSeriesTypeFactory()
self.series = factories.VaccineSeriesFactory(
author=self.user,
author_type=self.user.groups.first(),
patient=self.pt,
kind=self.series_type)
self.vai = models.VaccineActionItem.objects.create(
instruction=ActionInstruction.objects.create(
instruction="Please call"),
due_date=datetime.date.today(),
comments="",
author=self.user,
author_type=self.user.groups.first(),
patient=self.pt,
vaccine=self.series)
