def test_cant_own_case(self):
_, _, [case] = FormProcessorInterface.submit_form_locally(ALICE_XML, ALICE_DOMAIN)
response, form, cases = FormProcessorInterface.submit_form_locally(EVE_XML, EVE_DOMAIN)
self.assertIn('IllegalCaseId', response.content)
self.assertFalse(hasattr(FormProcessorInterface.get_case(case.id), 'plan_to_buy_gun'))
FormProcessorInterface.submit_form_locally(ALICE_UPDATE_XML, ALICE_DOMAIN)
self.assertEqual(FormProcessorInterface.get_case(case.id).plan_to_buy_gun, 'no')
def _check_state(self, new_owner_id, expected_changed, update=None):
expected_ids = set(c._id for c in expected_changed)
for case in expected_changed:
expected = FormProcessorInterface.get_case(case._id)
self.assertEqual(new_owner_id, expected.owner_id)
if update:
for prop, value in update.items():
self.assertEqual(getattr(expected, prop), value)
for case in (c for c in self.all if c._id not in expected_ids):
remaining = FormProcessorInterface.get_case(case._id)
self.assertEqual(self.original_owner._id, remaining.owner_id)
def test_delete_sharing_form(self):
factory = CaseFactory()
c1, c2 = factory.create_or_update_cases([
CaseStructure(attrs={'create': True}),
CaseStructure(attrs={'create': True}),
])
with self.assertRaises(CommCareCaseError):
FormProcessorInterface.hard_delete_case(c1)
with self.assertRaises(CommCareCaseError):
FormProcessorInterface.hard_delete_case(c2)
self.assertIsNotNone(FormProcessorInterface.get_case(c1.id))
self.assertIsNotNone(FormProcessorInterface.get_case(c2.id))
def test_simple_delete(self):
factory = CaseFactory()
case = factory.create_case()
[case] = factory.create_or_update_case(CaseStructure(case_id=case._id, attrs={'update': {'foo': 'bar'}}))
self.assertIsNotNone(FormProcessorInterface.get_case(case.id))
self.assertEqual(2, len(case.xform_ids))
for form_id in case.xform_ids:
self.assertIsNotNone(FormProcessorInterface.get_xform(form_id))
FormProcessorInterface.hard_delete_case(case)
with self.assertRaises(CaseNotFound):
FormProcessorInterface.get_case(case.id)
for form_id in case.xform_ids:
with self.assertRaises(XFormNotFound):
FormProcessorInterface.get_xform(form_id)
def test_delete_with_related(self):
factory = CaseFactory()
parent = factory.create_case()
[child] = factory.create_or_update_case(
CaseStructure(attrs={'create': True}, walk_related=False, indices=[
CaseIndex(CaseStructure(case_id=parent._id))
]),
)
# deleting the parent should not be allowed because the child still references it
with self.assertRaises(CommCareCaseError):
FormProcessorInterface.hard_delete_case(parent)
# deleting the child is ok
FormProcessorInterface.hard_delete_case(child)
self.assertIsNotNone(FormProcessorInterface.get_case(parent.id))
with self.assertRaises(CaseNotFound):
FormProcessorInterface.get_case(child.id)
def test_case_management(self):
form_id = uuid.uuid4().hex
case_id = uuid.uuid4().hex
owner_id = uuid.uuid4().hex
case_block = CaseBlock(
create=True,
case_id=case_id,
case_type='person',
owner_id=owner_id,
update={
'property': 'original value'
}
).as_string()
submit_case_blocks(case_block, domain=self.domain, form_id=form_id)
# validate some assumptions
case = FormProcessorInterface.get_case(case_id)
self.assertEqual(case.type, 'person')
self.assertEqual(case.property, 'original value')
self.assertEqual([form_id], case.xform_ids)
self.assertEqual(2, len(case.actions))
for a in case.actions:
self.assertEqual(form_id, a.xform_id)
# submit a new form with a different case update
case_block = CaseBlock(
create=True,
case_id=case_id,
case_type='newtype',
owner_id=owner_id,
update={
'property': 'edited value'
}
).as_string()
submit_case_blocks(case_block, domain=self.domain, form_id=form_id)
case = FormProcessorInterface.get_case(case_id)
self.assertEqual(case.type, 'newtype')
self.assertEqual(case.property, 'edited value')
self.assertEqual([form_id], case.xform_ids)
self.assertEqual(2, len(case.actions))
for a in case.actions:
self.assertEqual(form_id, a.xform_id)
def testOutOfOrderSubmissions(self):
dir = os.path.join(os.path.dirname(__file__), "data", "ordering")
for fname in ('update_oo.xml', 'create_oo.xml'):
with open(os.path.join(dir, fname), "rb") as f:
xml_data = f.read()
FormProcessorInterface.submit_form_locally(xml_data)
case = FormProcessorInterface.get_case('30bc51f6-3247-4966-b4ae-994f572e85fe')
self.assertEqual('from the update form', case.pupdate)
self.assertEqual('from the create form', case.pcreate)
self.assertEqual('overridden by the update form', case.pboth)
def test_case_management_ordering(self):
case_id = uuid.uuid4().hex
owner_id = uuid.uuid4().hex
# create a case
case_block = CaseBlock(
create=True,
case_id=case_id,
case_type='person',
owner_id=owner_id,
).as_string()
create_form_id = submit_case_blocks(case_block, domain=self.domain)
# validate that worked
case = FormProcessorInterface.get_case(case_id)
self.assertEqual([create_form_id], case.xform_ids)
self.assertEqual([create_form_id], [a.xform_id for a in case.actions])
for a in case.actions:
self.assertEqual(create_form_id, a.xform_id)
edit_date = datetime.utcnow()
# set some property value
case_block = CaseBlock(
create=False,
case_id=case_id,
date_modified=edit_date,
update={
'property': 'first value',
}
).as_string()
edit_form_id = submit_case_blocks(case_block, domain=self.domain)
# validate that worked
case = FormProcessorInterface.get_case(case_id)
self.assertEqual(case.property, 'first value')
self.assertEqual([create_form_id, edit_form_id], case.xform_ids)
self.assertEqual([create_form_id, edit_form_id], [a.xform_id for a in case.actions])
# submit a second (new) form updating the value
case_block = CaseBlock(
create=False,
case_id=case_id,
update={
'property': 'final value',
}
).as_string()
second_edit_form_id = submit_case_blocks(case_block, domain=self.domain)
# validate that worked
case = FormProcessorInterface.get_case(case_id)
self.assertEqual(case.property, 'final value')
self.assertEqual([create_form_id, edit_form_id, second_edit_form_id], case.xform_ids)
self.assertEqual([create_form_id, edit_form_id, second_edit_form_id], [a.xform_id for a in
case.actions])
# deprecate the middle edit
case_block = CaseBlock(
create=False,
case_id=case_id,
date_modified=edit_date, # need to use the previous edit date for action sort comparisons
update={
'property': 'edited value',
'added_property': 'added value',
}
).as_string()
submit_case_blocks(case_block, domain=self.domain, form_id=edit_form_id)
# ensure that the middle edit stays in the right place and is applied
# before the final one
case = FormProcessorInterface.get_case(case_id)
self.assertEqual(case.property, 'final value')
self.assertEqual(case.added_property, 'added value')
self.assertEqual([create_form_id, edit_form_id, second_edit_form_id], case.xform_ids)
self.assertEqual([create_form_id, edit_form_id, second_edit_form_id], [a.xform_id for a in
case.actions])
