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 test_form_other_volunteer_options(self): """WorkupForm offers only non-attendings for 'other volunteers'""" form = WorkupForm() user_pks = [u.pk for u in self.users] other_vol_options = [c[0] for c in form['other_volunteer'].field.choices] # check that any user can be the other volunteer assert set(user_pks) == set(other_vol_options) assert len(user_pks) == len(other_vol_options) # check that error is thrown if one of the other volunteers # is the attending attending = build_user([user_factories.AttendingGroupFactory]) non_attending = build_user() form_data = wu_dict() form_data['attending'] = attending form_data['other_volunteer'] = [non_attending, attending] form = WorkupForm(data=form_data) assert form['other_volunteer'].errors # and that no error is thrown if they are different form_data['other_volunteer'] = [non_attending] form = WorkupForm(data=form_data) assert not form['other_volunteer'].errors
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 test_dispense_history_creation(self): assert DispenseHistory.objects.count() == 0 user = build_user() dispense_history = factories.DispenseHistoryFactory( author=user, author_type=user.groups.first()) assert isinstance(dispense_history, DispenseHistory) assert DispenseHistory.objects.count() == 1
def attestable_note_signing_one_group_test(self, note): """test signing permissions for attestable note when user has one group.""" for role in user_factories.all_roles: user = build_user([role]) group = user.groups.first() # attending can sign if role in user_factories.attesting_roles: note.sign(user, group) assert note.signed() else: # non-attending can't sign with self.assertRaises(ValueError): note.sign(user, group) assert not note.signed() # non-attending can't use another group to sign with self.assertRaises(ValueError): note.sign(user, user_factories.AttendingGroupFactory()) assert not note.signed() # reset chart's signed status note.signer = None
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 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 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.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 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 test_login(self): ''' Test the login sequence for one clinical role and mulitiple clinical roles. ''' build_user(username='******', password='******', group_factories=[ user_factories.CaseManagerGroupFactory, user_factories.VolunteerGroupFactory ]) # any valid URL should redirect to login at this point. self.get_homepage() self.submit_login('jrporter', 'password') # now we should have to choose a clinical role assert self.selenium.current_url == '%s%s%s' % ( self.live_server_url, reverse('core:choose-role'), '?next=%s' % reverse('dashboard-dispatch')) self.selenium.find_element_by_xpath( '//input[@name="radio-roles"]').click() self.selenium.find_element_by_xpath('//button[@type="submit"]').click() WebDriverWait(self.selenium, self.DEFAULT_WAIT_TIME).until( EC.presence_of_element_located((By.ID, "all-patients-table"))) assert self.selenium.current_url == '%s%s' % ( self.live_server_url, reverse('dashboard-active')) self.logout() # make a provider with only one role. build_user(username='******', password='******', group_factories=[user_factories.AttendingGroupFactory]) self.get_homepage() self.submit_login('timmy', 'password') # now we should be redirected directly to home. assert self.selenium.current_url == '%s%s' % ( self.live_server_url, reverse('dashboard-active'))
def setUp(self): self.user = build_user() self.apt = models.Appointment.objects.create( comment='test this stuff', clindate=now().date(), 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.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 test_core_patient_detail_collapseable(self): """Ensure that collapsable AI lists open and close with AIs inside """ user = build_user(password='******', group_factories=[user_factories.AttendingGroupFactory]) self.get_homepage() self.submit_login(user.username, 'password') ai_prototype = { 'instruction': models.ActionInstruction.objects.first(), 'comments': "", 'author_type': user.groups.first(), 'patient': models.Patient.objects.first(), 'author': user } models.ActionItem.objects.create( due_date=now().today(), **ai_prototype ) yesterday = now().date() - datetime.timedelta(days=1) models.ActionItem.objects.create( due_date=yesterday, **ai_prototype ) self.selenium.get('%s%s' % (self.live_server_url, reverse('core:patient-detail', args=(1,)))) active_action_item_id = 'collapse8' WebDriverWait(self.selenium, 2).until( EC.presence_of_element_located( (By.ID, 'toggle-' + active_action_item_id))) assert not (self.selenium.find_element_by_id(active_action_item_id) .find_element_by_xpath('./ul/li') .is_displayed()) assert len(self.selenium.find_element_by_id(active_action_item_id) .find_elements_by_xpath('./ul/li')) == 2 self.selenium.find_element_by_id('toggle-' + active_action_item_id).click() WebDriverWait(self.selenium, 2).until( EC.presence_of_element_located( (By.XPATH, '//div[@class="panel-collapse collapse in"]'))) assert len(self.selenium.find_element_by_id(active_action_item_id) .find_elements_by_xpath('./ul/li')) == 2 assert (self.selenium.find_element_by_id(active_action_item_id) .find_element_by_xpath('./ul/li') .is_displayed())
def setUp(self): # build large list of users with different combinations of roles self.users = [] role_list = list(user_factories.all_roles) role_powerset = chain.from_iterable( combinations(role_list, r) for r in range(1, len(role_list)+1)) for role_tuple in role_powerset: for _ in range(3): self.users.append(build_user(list(role_tuple)))
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 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): 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() for i in range(settings.OSLER_MAX_APPOINTMENTS): models.Appointment.objects.create( comment=str(i), clindate=now().date(), author=self.user, author_type=self.user.groups.first(), patient=Patient.objects.first())
def test_pending_wu_signing(self): """Pending workups should not be able to be signed.""" self.wu.is_pending = True self.wu.save() user = build_user([user_factories.AttendingGroupFactory]) group = user.groups.first() with self.assertRaises(ValueError): self.wu.sign(user, group)
def apt_dict(): apt = { 'clindate': now().date(), 'clintime': time(9, 0), 'appointment_type': 'PSYCH_NIGHT', 'comment': 'stuff', 'author': build_user(), 'patient': core_factories.PatientFactory().id } apt['author_type'] = apt['author'].groups.first() return apt
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 wu_dict(user=None, units=False, dx_category=False): if not user: user = build_user() fake_text = 'abc' pt = core_factories.PatientFactory() status = core_factories.EncounterStatusFactory() e = Encounter.objects.create(patient=pt, clinic_day=now().date(), status=status) wu = { 'encounter': e, 'chief_complaint': "SOB", 'diagnosis': "MI", 'hpi': fake_text, 'pmh': fake_text, 'psh': fake_text, 'meds': fake_text, 'allergies': fake_text, 'fam_hx': fake_text, 'soc_hx': fake_text, 'ros': "f", 'pe': "f", 'a_and_p': "f", 'hr': '89', 'bp_sys': '120', 'bp_dia': '80', 'rr': '16', 't': '98', 'labs_ordered_internal': 'f', 'labs_ordered_external': 'f', 'got_voucher': False, 'got_imaging_voucher': False, 'author': user, 'author_type': user.groups.first(), 'patient': pt } if units: wu['temperature_units'] = 'F' wu['weight_units'] = 'lbs' wu['height_units'] = 'in' if dx_category: wu['diagnosis_categories'] = [models.DiagnosisType.objects.first().pk] return wu
def test_core_view_rendering(self): ''' Test that core urls render correctly, as determined by the existence of a jumbotron at the top. ''' from django.urls import NoReverseMatch # build a provider and log in. user = build_user( password='******', group_factories=[user_factories.CaseManagerGroupFactory]) self.get_homepage() self.submit_login(user.username, 'password') for url in urls.urlpatterns: # except 'core:choose-role' and action item modifiers from test # since they're redirects. if url.name in [ 'choose-role', 'done-action-item', 'reset-action-item', 'document-detail', 'document-update', 'update-action-item' ]: # TODO: add test data for documents so document-detail and # document-update can be tested as well. continue # all the URLs have either one parameter or none. Try one # parameter first; if that fails, try with none. try: self.selenium.get( '%s%s' % (self.live_server_url, reverse("%s%s" % ("core:", url.name), args=(1, )))) except NoReverseMatch: self.selenium.get( '%s%s' % (self.live_server_url, reverse("%s%s" % ("core:", url.name)))) WebDriverWait(self.selenium, self.DEFAULT_WAIT_TIME).until( EC.presence_of_element_located( (By.XPATH, '//div[@class="jumbotron"]'))) jumbotron_elements = self.selenium.find_elements_by_xpath( '//div[@class="jumbotron"]') self.assertNotEqual(len(jumbotron_elements), 0, msg=" ".join([ "Expected the URL ", url.name, " to have a jumbotron element." ]))
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)