def testMismatch(self):
self.assertEqual(CaseStateHash(EMPTY_HASH), self.sync_log.get_state_hash())
c1 = CaseBlock(case_id="abc123", create=True,
owner_id=self.user.user_id).as_xml()
c2 = CaseBlock(case_id="123abc", create=True,
owner_id=self.user.user_id).as_xml()
FormProcessorInterface.post_case_blocks([c1, c2],
form_extras={"last_sync_token": self.sync_log.get_id})
self.sync_log = get_properly_wrapped_sync_log(self.sync_log.get_id)
real_hash = CaseStateHash("409c5c597fa2c2a693b769f0d2ad432b")
bad_hash = CaseStateHash("thisisntright")
self.assertEqual(real_hash, self.sync_log.get_state_hash())
generate_restore_payload(
self.project, self.user, self.sync_log.get_id,
version=V2, state_hash=str(real_hash)
)
try:
generate_restore_payload(self.project, self.user, self.sync_log.get_id,
version=V2, state_hash=str(bad_hash))
self.fail("Call to generate a payload with a bad hash should fail!")
except BadStateException, e:
self.assertEqual(real_hash, e.server_hash)
self.assertEqual(bad_hash, e.phone_hash)
self.assertEqual(2, len(e.case_ids))
self.assertTrue("abc123" in e.case_ids)
self.assertTrue("123abc" in e.case_ids)
def setUp(self):
delete_all_xforms()
delete_all_cases()
FormProcessorInterface.post_case_blocks(
[CaseBlock(create=True, case_id="mother_case_id", case_type="mother-case").as_xml()],
{"domain": TEST_DOMAIN},
)
self.case_id = "test_case_1"
self.date_modified = datetime.utcnow() - timedelta(hours=1)
self.date_modified = self.date_modified.replace(microsecond=0)
FormProcessorInterface.post_case_blocks(
[
CaseBlock(
create=True,
case_id=self.case_id,
owner_id="owner",
user_id="user",
case_type="c_type",
case_name=("a" * TEST_NAME_LEN) + "123456789",
external_id="external_id",
date_modified=self.date_modified,
update={"foo": "bar"},
index={"mom": ("mother-case", "mother_case_id")},
).as_xml()
],
{"domain": TEST_DOMAIN},
)
instance = CommCareCase.get(self.case_id)
self.casedata = CaseData.create_or_update_from_instance(instance)
def update_and_test(case_id, owner=None, should_have=None, should_not_have=None):
case_block = self.get_update_block(
case_id=case_id,
update={'greeting': "Hello!"},
owner_id=owner.get_id if owner else None,
)
FormProcessorInterface.post_case_blocks([case_block], {'domain': self.domain})
check_has_block(case_block, should_have, should_not_have, line_by_line=False)
def add_parent_access(self, user, case):
case_block = CaseBlock(
create=True,
case_id=uuid.uuid4().hex,
case_type='magic_map',
owner_id=user._id,
index={'parent': ('participant', case._id)}
).as_xml()
FormProcessorInterface.post_case_blocks([case_block], {'domain': self.domain})
def create_and_test(case_id, user, owner, should_have, should_not_have):
case_block = self.get_create_block(
case_id=case_id,
type="case",
user_id=user.user_id,
owner_id=owner.get_id,
)
FormProcessorInterface.post_case_blocks([case_block], {'domain': self.domain})
check_has_block(case_block, should_have, should_not_have)
def update_case_owner(self, case, owner):
case_block = CaseBlock(
create=False,
case_id=case._id,
case_type='participant',
owner_id=owner._id,
user_id=owner._id,
).as_xml()
FormProcessorInterface.post_case_blocks([case_block], {'domain': self.domain})
def _new_case(cls, properties):
id = uuid.uuid4().hex
case_block = CaseBlock(
create=True,
case_id=id,
case_type=cls.case_type,
update=properties,
).as_xml()
FormProcessorInterface.post_case_blocks([case_block], {'domain': cls.domain})
return CommCareCase.get(id)
def test_empty_name(self):
case_id = "case_with_no_name"
FormProcessorInterface.post_case_blocks(
[CaseBlock(create=True, case_id=case_id, case_type="nameless").as_xml()], {"domain": TEST_DOMAIN}
)
instance = CommCareCase.get(case_id)
casedata = CaseData.create_or_update_from_instance(instance)
self.assertIsNotNone(casedata)
self.assertEqual("", casedata.name)
def testRelationshipGetsSet(self):
user = User(user_id=USER_ID, username="", password="", date_joined="")
create_index = CaseBlock(
create=True,
case_id=self.CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
index={'mom': ('mother-case', self.MOTHER_CASE_ID, 'extension')},
).as_xml()
FormProcessorInterface.post_case_blocks([create_index])
check_user_has_case(self, user, create_index)
def _make_some_cases(howmany, domain='dbcache-test'):
ids = [uuid.uuid4().hex for i in range(howmany)]
FormProcessorInterface.post_case_blocks([
CaseBlock(
create=True,
case_id=ids[i],
user_id='some-user',
update={
'my_index': i,
}
).as_xml() for i in range(howmany)
], {'domain': domain})
return ids
def test_update(self):
FormProcessorInterface.post_case_blocks(
[
CaseBlock(
create=True, case_id="grand_mother_case_id", case_type="mother-case", owner_id="owner"
).as_xml()
],
{"domain": TEST_DOMAIN},
)
date_modified = datetime.utcnow()
FormProcessorInterface.post_case_blocks(
[
CaseBlock(
close=True,
case_id=self.case_id,
user_id="user2",
date_modified=date_modified,
index={"gmom": ("mother-case", "grand_mother_case_id")},
).as_xml()
],
{"domain": TEST_DOMAIN},
)
instance = CommCareCase.get(self.case_id)
updateddata = CaseData.create_or_update_from_instance(instance)
self.assertEqual(date_modified, updateddata.modified_on)
self.assertEqual("user2", updateddata.modified_by)
self.assertEqual(date_modified, updateddata.closed_on)
self.assertEqual(True, updateddata.closed)
actions = updateddata.actions.all()
self.assertEqual(5, len(actions))
for action in actions:
if action.index == 4:
self.assertEqual("close", action.action_type)
self.assertEqual(date.today(), action.date.date())
self.assertEqual(date.today(), action.server_date.date())
self.assertEqual("user2", action.user_id)
self.assertEqual("owner", action.case_owner)
self.assertEqual("c_type", action.case_type)
indices = self.casedata.indices.all()
self.assertEqual(2, len(indices))
self.assertEqual("gmom", indices[0].identifier)
self.assertEqual("mother-case", indices[0].referenced_type)
self.assertEqual("grand_mother_case_id", indices[0].referenced_id)
self.assertEqual("mom", indices[1].identifier)
self.assertEqual("mother-case", indices[1].referenced_type)
self.assertEqual("mother_case_id", indices[1].referenced_id)
def _new_case(self, index=None):
index = index or {}
id = uuid.uuid4().hex
case_block = CaseBlock(
create=True, case_id=id, case_type="person", owner_id=self.original_owner._id, index=index
).as_xml()
_, [case] = FormProcessorInterface.post_case_blocks([case_block], {"domain": self.domain})
return case
def testSubmitToDeletedCase(self):
# submitting to a deleted case should succeed and affect the case
case_id = 'immagetdeleted'
deleted_doc_type = 'CommCareCase-Deleted'
[xform, [case]] = FormProcessorInterface.post_case_blocks([
CaseBlock(create=True, case_id=case_id, user_id='whatever',
update={'foo': 'bar'}).as_xml()
])
self.assertEqual('bar', case.foo)
case = FormProcessorInterface.update_case_properties(case, doc_type=deleted_doc_type)
self.assertEqual(deleted_doc_type, case.doc_type)
[xform, [case]] = FormProcessorInterface.post_case_blocks([
CaseBlock(create=False, case_id=case_id, user_id='whatever',
update={'foo': 'not_bar'}).as_xml()
])
self.assertEqual('not_bar', case.foo)
self.assertEqual(deleted_doc_type, case.doc_type)
def testArchiveModifiedOn(self):
case_id = uuid.uuid4().hex
now = datetime.utcnow().replace(microsecond=0)
earlier = now - timedelta(hours=1)
way_earlier = now - timedelta(days=1)
# make sure we timestamp everything so they have the right order
create_block = CaseBlock(case_id, create=True, date_modified=way_earlier)
FormProcessorInterface.post_case_blocks([create_block.as_xml()], form_extras={'received_on': way_earlier})
update_block = CaseBlock(case_id, update={'foo': 'bar'}, date_modified=earlier)
FormProcessorInterface.post_case_blocks([update_block.as_xml()], form_extras={'received_on': earlier})
case = CommCareCase.get(case_id)
self.assertEqual(earlier, case.modified_on)
second_form = XFormInstance.get(case.xform_ids[-1])
second_form.archive()
case = CommCareCase.get(case_id)
self.assertEqual(way_earlier, case.modified_on)
def testBadIndexReferenceDomain(self):
case_in_other_domain = self.MOTHER_CASE_ID
parent_domain = 'parent'
child_domain = 'child'
FormProcessorInterface.post_case_blocks([
CaseBlock(create=True, case_id=case_in_other_domain, user_id=USER_ID).as_xml()
], form_extras={'domain': parent_domain})
block = CaseBlock(create=True, case_id='child-case-id', user_id=USER_ID,
index={'bad': ('bad-case', case_in_other_domain)})
xform, _ = FormProcessorInterface.post_case_blocks([block.as_xml()],
form_extras={'domain': child_domain})
self.assertTrue(xform.is_error)
self.assertEqual(xform.doc_type, 'XFormError')
self.assertIn('IllegalCaseId', xform.problem)
self.assertIn('Bad case id', xform.problem)
def testDomainCheck(self):
id = uuid.uuid4().hex
FormProcessorInterface.post_case_blocks([
CaseBlock(
create=True, case_id=id,
user_id='some-user'
).as_xml()
], {'domain': 'good-domain'}
)
bad_cache = CaseDbCache(domain='bad-domain')
try:
bad_cache.get(id)
self.fail('domain security check failed to raise exception')
except IllegalCaseId:
pass
good_cache = CaseDbCache(domain='good-domain')
case = good_cache.get(id)
self.assertEqual('some-user', case.user_id) # just sanity check it's the right thing
def create_scan_case(self, user_id, serial, scan_id, scan_time, scan_status=''):
case_id = uuid.uuid4().hex
case_block = CaseBlock(
create=True,
case_id=case_id,
case_name='scan',
case_type=UTH_CASE_TYPE,
user_id=user_id,
owner_id=user_id,
update={
'exam_number': scan_id,
'scanner_serial': serial,
'scan_status': scan_status,
'scan_time': scan_time
}
).as_xml()
FormProcessorInterface.post_case_blocks([case_block], {'domain': UTH_DOMAIN})
return case_id
def _post_util(create=False, case_id=None, user_id=None, owner_id=None,
case_type=None, form_extras=None, close=False, date_modified=None,
**kwargs):
form_extras = form_extras or {}
form_extras['domain'] = 'rebuild-test'
uid = lambda: uuid.uuid4().hex
case_id = case_id or uid()
block = CaseBlock(create=create,
case_id=case_id,
user_id=user_id or uid(),
owner_id=owner_id or uid(),
case_type=case_type or 'test',
date_modified=date_modified,
update=kwargs,
close=close).as_xml()
FormProcessorInterface.post_case_blocks([block], form_extras)
return case_id
def test_empty_owner_id(self):
case_id = "case_with_no_owner"
FormProcessorInterface.post_case_blocks(
[
CaseBlock(
create=True,
case_id=case_id,
user_id="user",
case_type="c_type",
case_name="bob",
date_modified=self.date_modified,
update={"foo": "bar"},
).as_xml()
],
{"domain": TEST_DOMAIN},
)
instance = CommCareCase.get(case_id)
casedata = CaseData.create_or_update_from_instance(instance)
self.assertIsNotNone(casedata)
self.assertEqual("user", casedata.case_owner)
def _create_case(user, type, close=False, **extras):
case_id = uuid.uuid4().hex
blocks = [CaseBlock(
create=True,
case_id=case_id,
case_name=_type_to_name(type),
case_type=type,
user_id=user.user_id,
owner_id=user.user_id,
**extras
).as_xml(format_datetime=date_to_xml_string)]
if close:
blocks.append(CaseBlock(
create=False,
case_id=case_id,
close=True,
).as_xml(format_datetime=date_to_xml_string))
FormProcessorInterface.post_case_blocks(blocks, {'domain': TEST_DOMAIN})
case = CommCareCase.get(case_id)
assert case.closed == close
return case
def _submit_case(domain):
case_id = uuid.uuid4().hex
case_block = CaseBlock(
create=True,
case_id=case_id,
case_name='donald',
case_type='duck',
user_id=user._id,
owner_id=user._id,
).as_xml()
_, [case] = FormProcessorInterface.post_case_blocks([case_block], {'domain': domain})
return case
def testIndexes(self):
user = User(user_id=USER_ID, username="", password="", date_joined="")
# Step 0. Create mother and father cases
for prereq in [self.MOTHER_CASE_ID, self.FATHER_CASE_ID]:
FormProcessorInterface.post_case_blocks([
CaseBlock(create=True, case_id=prereq, user_id=USER_ID).as_xml()
])
# Step 1. Create a case with index <mom>
create_index = CaseBlock(
create=True,
case_id=self.CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
index={'mom': ('mother-case', self.MOTHER_CASE_ID)},
).as_xml()
FormProcessorInterface.post_case_blocks([create_index])
check_user_has_case(self, user, create_index)
# Step 2. Update the case to delete <mom> and create <dad>
now = datetime.datetime.utcnow()
update_index = CaseBlock(
case_id=self.CASE_ID,
user_id=USER_ID,
index={'mom': ('mother-case', ''), 'dad': ('father-case', self.FATHER_CASE_ID)},
date_modified=now,
).as_xml()
update_index_expected = CaseBlock(
case_id=self.CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
create=True,
index={'dad': ('father-case', self.FATHER_CASE_ID)},
date_modified=now,
).as_xml()
FormProcessorInterface.post_case_blocks([update_index])
check_user_has_case(self, user, update_index_expected)
# Step 3. Put <mom> back
now = datetime.datetime.utcnow()
update_index = CaseBlock(
case_id=self.CASE_ID,
user_id=USER_ID,
index={'mom': ('mother-case', self.MOTHER_CASE_ID)},
date_modified=now,
).as_xml()
update_index_expected = CaseBlock(
case_id=self.CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
create=True,
index={'mom': ('mother-case', self.MOTHER_CASE_ID),
'dad': ('father-case', self.FATHER_CASE_ID)},
date_modified=now,
).as_xml()
FormProcessorInterface.post_case_blocks([update_index])
check_user_has_case(self, user, update_index_expected)
