def testCaseManager(self):
pt1, cgs1, prov1 = generator.generate_patient_and_careteam()
pt2, cgs2, prov2 = generator.generate_patient_and_careteam()
actor_creator = generator.generate_actor(generator.get_or_create_user(), "provider")
actor_editor1 = generator.generate_actor(generator.get_or_create_user(), "provider")
actor_editor2 = generator.generate_actor(generator.get_or_create_user(), "provider")
actor_closer = generator.generate_actor(generator.get_or_create_user(), "provider")
total_cases = 12
for i in range(total_cases):
case = self._create_case(actor_creator, uuid.uuid1().hex)
case.patient = pt1
if i%2 == 0:
case.last_edit_by = actor_editor1
else:
case.last_edit_by = actor_editor2
case.description = "edited, foolio: " + str(uuid.uuid1().hex)
activity=ActivityClass.objects.filter(event_class=constants.CASE_EVENT_EDIT)[0]
case.save(activity=activity)
self.assertEqual(total_cases, Case.objects.get_authored(actor_creator).count())
self.assertEqual(0, Case.objects.get_authored(actor_creator, patient=pt2).count())
self.assertEqual(total_cases/2, Case.objects.get_edited(actor_editor1).count())
self.assertEqual(total_cases/2, Case.objects.get_edited(actor_editor2).count())
self.assertEqual(total_cases/2, Case.objects.get_edited(actor_editor1, patient=pt1).count())
self.assertEqual(0, Case.objects.get_edited(actor_editor1, patient=pt2).count())
self.assertEqual(total_cases/2, Case.objects.get_edited(actor_editor2, patient=pt1).count())
self.assertEqual(0, Case.objects.get_edited(actor_editor2, patient=pt2).count())
def testCaseModifyDescriptionApi(self):
desc= uuid.uuid1().hex
self.testCreateCaseApi(description=desc)
user1 = generator.get_or_create_user()
actor1 = generator.generate_role(user1, 'provider')
case = Case.objects.all().get(description=desc)
case.description = CHANGED_DESCRIPTION
case.last_edit_by = actor1
activity = constants.CASE_EVENT_EDIT
case.save_comment="editing in testCaseModifyDescription"
case.save(activity=activity)
events = CaseEvent.objects.filter(case=case)
#we just did an edit, so it should be 2
self.assertEqual(2, events.count())
#the top one due to the sort ordering should be the one we just did
self.assertEqual(constants.CASE_EVENT_EDIT, events[0].activity)
#quickly verify that the original description is still unchanged
dbcase = Case.objects.all().get(description=CHANGED_DESCRIPTION)
self.assertEqual(dbcase.id, case.id)
def testCreateCaseApi(self, description=INITIAL_DESCRIPTION):
###########################
#get the basic counts
user1 = generator.get_or_create_user()
user2 = generator.get_or_create_user()
role1 = generator.generate_role(user1, 'caregiver')
role2 = generator.generate_role(user2, 'provider')
oldcasecount = Case.objects.all().count()
oldevents = CaseEvent.objects.all().count()
# newcase = Case()
# newcase.description = description
# newcase.opened_by = role1
# newcase.last_edit_by = role1
#
# newcase.assigned_date = datetime.utcnow()
# newcase.assigned_to = role2
# newcase.category = Category.objects.all()[0]
# newcase.status = Status.objects.all().filter(state_class=constants.CASE_STATE_OPEN)[0]
# newcase.priority = Priority.objects.all()[0]
# activity = ActivityClass.objects.filter(event_class=constants.CASE_EVENT_OPEN)[0]
# newcase.save(activity=activity)
newcase = Case.objects.new_case(constants.CATEGORY_CHOICES[0][0],
role1,
description,
"mock body %s" % (uuid.uuid1().hex),
constants.PRIORITY_MEDIUM,
status=constants.CASE_STATE_OPEN,
activity=constants.CASE_EVENT_OPEN
)
#is the thing created?
self.assertEqual(Case.objects.all().count(), oldcasecount + 1)
self.assertEqual(CaseEvent.objects.all().count(), oldevents + 1)
#verify that the case count created has created a new caseevent
events = CaseEvent.objects.filter(case=newcase)
self.assertEqual(1,events.count())
#verify that said case count is a new case event of type "open"
self.assertEqual(constants.CASE_EVENT_OPEN, events[0].activity)
return newcase
def testBusyProvider(self):
"""Create a single provider/user caring for many patients."""
num_patients = 20
my_patients = 5
user = generator.get_or_create_user()
actor = generator.generate_role(user, 'provider')
patients = [generator.get_or_create_patient() for i in range(num_patients)]
for i in range(my_patients):
patients[i].add_actor(actor)
def testCreateSingleCareTeamAPI(self):
print "===========================\nCreating singular patient with careteam via API"
pt = generator.get_or_create_patient()
provrole = generator.generate_role(generator.get_or_create_user(), 'provider')
pt.add_provider(provoler)
provrole = generator.generate_role(generator.get_or_create_user(), 'provider')
pt.add_provider(provoler)
provrole = generator.generate_role(generator.get_or_create_user(), 'provider')
pt.add_provider(provoler)
cgrole = generator.generate_role(generator.get_or_create_user(), 'caregiver')
pt.add_caregiver(cgoler)
cgrole = generator.generate_role(generator.get_or_create_user(), 'caregiver')
pt.add_caregiver(cgoler)
#next, verify single careteam exists via the patient access API.
cg_pull = pt.get_caregivers()
prov_pull = pt.get_providers()
self.assertEqual(2, cg_pull.count())
self.assertEqual(3, prov_pull.count())
def testCaseCreateChildCases(self):
self.testCreateCaseApi()
user1 = generator.get_or_create_user()
role1 = generator.generate_role(user1, 'provider')
case = Case.objects.all().get(description =INITIAL_DESCRIPTION)
CHILD_CASES=10
for num in range(0,CHILD_CASES):
desc = uuid.uuid1().hex
newcase = self.testCreateCaseApi(description=desc)
newcase.parent_case = case
newcase.last_edit_by = role1
activity = constants.CASE_EVENT_EDIT
newcase.save_comment="editing in testCaseCreateChildCases"
newcase.save(activity=activity)
self.assertEqual(case.child_cases.count(), CHILD_CASES)
