def claim_case(domain, owner_id, host_id, host_type=None, host_name=None):
"""
Claim a case identified by host_id for claimant identified by owner_id.
Creates an extension case so that the claimed case is synced to the claimant's device.
"""
claim_id = uuid4().hex
if not (host_type and host_name):
case = CaseAccessors(domain).get_case(host_id)
host_type = case.type
host_name = case.name
identifier = DEFAULT_CASE_INDEX_IDENTIFIERS[CASE_INDEX_EXTENSION]
claim_case_block = CaseBlock(
create=True,
case_id=claim_id,
case_name=host_name,
case_type=CLAIM_CASE_TYPE,
owner_id=owner_id,
index={
identifier: IndexAttrs(
case_type=host_type,
case_id=host_id,
relationship=CASE_INDEX_EXTENSION,
)
}
).as_xml()
post_case_blocks([claim_case_block], {'domain': domain})
return claim_id
def _close_case(self, case_id):
case_block = CaseBlock(
create=False,
case_id=case_id,
close=True
).as_xml()
post_case_blocks([case_block], {'domain': DOMAIN})
def testCacheNonInvalidation(self):
original_payload = RestoreConfig(
self.user,
version=V2,
caching_enabled=True,
restore_id=self.sync_log._id,
).get_payload()
self.sync_log = SyncLog.get(self.sync_log._id)
self.assertTrue(self.sync_log.has_cached_payload(V2))
# posting a case associated with this sync token should invalidate the cache
# submitting a case not with the token will not touch the cache for that token
case_id = "cache_noninvalidation"
post_case_blocks([
CaseBlock(
create=True,
case_id=case_id,
user_id=self.user.user_id,
owner_id=self.user.user_id,
case_type=PARENT_TYPE,
version=V2,
).as_xml()
])
next_payload = RestoreConfig(
self.user,
version=V2,
caching_enabled=True,
restore_id=self.sync_log._id,
).get_payload()
self.assertEqual(original_payload, next_payload)
self.assertFalse(case_id in next_payload)
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,
version=V2,
**extras
).as_xml(format_datetime=date_to_xml_string)]
if close:
blocks.append(CaseBlock(
create=False,
case_id=case_id,
close=True,
version=V2,
).as_xml(format_datetime=date_to_xml_string))
post_case_blocks(blocks)
case = CommCareCase.get(case_id)
assert case.closed == close
case.domain = TEST_DOMAIN
case.save()
return case
def _close_case(self, case_id):
case_block = CaseBlock(
create=False,
case_id=case_id,
close=True
).as_xml()
post_case_blocks([case_block], {'domain': DOMAIN})
def test_archie_modified_on(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)
post_case_blocks([create_block.as_xml()],
form_extras={'received_on': way_earlier})
update_block = CaseBlock(case_id,
update={'foo': 'bar'},
date_modified=earlier)
post_case_blocks([update_block.as_xml()],
form_extras={'received_on': earlier})
case = CommCareCase.objects.get_case(case_id, 'test-domain')
self.assertEqual(earlier, case.modified_on)
second_form = XFormInstance.objects.get_form(case.xform_ids[-1],
'test-domain')
second_form.archive()
case = CommCareCase.objects.get_case(case_id, 'test-domain')
self.assertEqual(way_earlier, case.modified_on)
def _run_test(self, event_type, expected_records_after_create,
expected_records_after_update):
ZapierSubscription.objects.create(
domain=self.domain,
user_id=str(self.web_user._id),
event_name=event_type,
url='http://example.com/lets-make-some-cases/',
case_type='animal',
)
# create case and run checks
case_id = uuid.uuid4().hex
post_case_blocks([
CaseBlock(
create=True,
case_id=case_id,
case_type='animal',
).as_xml()
],
domain=self.domain)
repeat_records = list(RepeatRecord.all(domain=self.domain))
self.assertEqual(expected_records_after_create, len(repeat_records))
for record in repeat_records:
self.assertEqual(case_id, record.payload_id)
# update case and run checks
post_case_blocks([CaseBlock(
create=False,
case_id=case_id,
).as_xml()],
domain=self.domain)
repeat_records = list(RepeatRecord.all(domain=self.domain))
self.assertEqual(expected_records_after_update, len(repeat_records))
for record in repeat_records:
self.assertEqual(case_id, record.payload_id)
def test_archie_modified_on(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)
post_case_blocks([create_block.as_xml()],
form_extras={'received_on': way_earlier})
update_block = CaseBlock(case_id,
update={'foo': 'bar'},
date_modified=earlier)
post_case_blocks([update_block.as_xml()],
form_extras={'received_on': earlier})
case_accessors = CaseAccessors(REBUILD_TEST_DOMAIN)
case = case_accessors.get_case(case_id)
self.assertEqual(earlier, case.modified_on)
second_form = FormAccessors(REBUILD_TEST_DOMAIN).get_form(
case.xform_ids[-1])
second_form.archive()
case = case_accessors.get_case(case_id)
self.assertEqual(way_earlier, case.modified_on)
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_DOMAIN
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)
block = block.as_xml()
post_case_blocks([block], form_extras)
return case_id
def setUp(self):
delete_all_xforms()
delete_all_cases()
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)
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 testBadIndexReferenceDomain(self):
case_in_other_domain = self.MOTHER_CASE_ID
parent_domain = 'parent'
child_domain = 'child'
post_case_blocks([
CaseBlock(create=True,
case_id=case_in_other_domain,
user_id=USER_ID,
version=V2).as_xml()
],
form_extras={'domain': parent_domain})
block = CaseBlock(create=True,
case_id='child-case-id',
user_id=USER_ID,
version=V2,
index={'bad': ('bad-case', case_in_other_domain)})
xform, _ = post_case_blocks([block.as_xml()],
form_extras={'domain': child_domain})
self.assertIsInstance(xform, XFormError)
self.assertEqual(xform.doc_type, 'XFormError')
self.assertIn('IllegalCaseId', xform.problem)
self.assertIn('Bad case id', xform.problem)
def testSubmitToDeletedCase(self):
# submitting to a deleted case should succeed and affect the case
case_id = uuid.uuid4().hex
xform, [case] = post_case_blocks([
CaseBlock(create=True,
case_id=case_id,
user_id='whatever',
update={
'foo': 'bar'
}).as_xml()
])
case.soft_delete()
self.assertEqual('bar', case.dynamic_case_properties()['foo'])
self.assertTrue(case.is_deleted)
xform, [case] = post_case_blocks([
CaseBlock(create=False,
case_id=case_id,
user_id='whatever',
update={
'foo': 'not_bar'
}).as_xml()
])
self.assertEqual('not_bar', case.dynamic_case_properties()['foo'])
self.assertTrue(case.is_deleted)
def test_submission_with_bad_log_default(self):
with self.assertRaises(ResourceNotFound):
post_case_blocks(
[CaseBlock(create=True, case_id='bad-log-default', version=V2).as_xml()],
form_extras={"last_sync_token": 'not-a-valid-synclog-id'},
domain='some-domain-without-toggle',
)
def setUp(self):
delete_all_xforms()
delete_all_cases()
post_case_blocks([
CaseBlock(
create=True,
case_id='mother_case_id',
case_type='mother-case',
version=V2,
).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)
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,
version=V2,
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 testCacheNonInvalidation(self):
original_payload = RestoreConfig(
self.user, version=V2, caching_enabled=True,
restore_id=self.sync_log._id,
).get_payload()
self.sync_log = SyncLog.get(self.sync_log._id)
self.assertTrue(self.sync_log.has_cached_payload(V2))
# posting a case associated with this sync token should invalidate the cache
# submitting a case not with the token will not touch the cache for that token
case_id = "cache_noninvalidation"
post_case_blocks([CaseBlock(
create=True,
case_id=case_id,
user_id=self.user.user_id,
owner_id=self.user.user_id,
case_type=PARENT_TYPE,
version=V2,
).as_xml()])
next_payload = RestoreConfig(
self.user, version=V2, caching_enabled=True,
restore_id=self.sync_log._id,
).get_payload()
self.assertEqual(original_payload, next_payload)
self.assertFalse(case_id in next_payload)
def testSubmitToDeletedCase(self):
# submitting to a deleted case should succeed and affect the case
case_id = 'immagetdeleted'
deleted_doc_type = 'CommCareCase-Deleted'
post_case_blocks([
CaseBlock(create=True,
case_id=case_id,
user_id='whatever',
version=V2,
update={
'foo': 'bar'
}).as_xml()
])
case = CommCareCase.get(case_id)
self.assertEqual('bar', case.foo)
# hack copy how we delete things
case.doc_type = deleted_doc_type
case.save()
self.assertEqual(deleted_doc_type, case.doc_type)
post_case_blocks([
CaseBlock(create=False,
case_id=case_id,
user_id='whatever',
version=V2,
update={
'foo': 'not_bar'
}).as_xml()
])
case = CommCareCase.get(case_id)
self.assertEqual('not_bar', case.foo)
self.assertEqual(deleted_doc_type, case.doc_type)
def _new_case(self, properties):
id = uuid.uuid4().hex
case_block = CaseBlock(
create=True, case_id=id, case_type=self.case_type, version=V2, update=properties
).as_xml()
post_case_blocks([case_block], {"domain": self.domain})
return CommCareCase.get(id)
def test_submit_to_deleted_case(self):
"""submitting to a deleted case should succeed and affect the case"""
case_id = uuid.uuid4().hex
xform, [case] = post_case_blocks([
CaseBlock(create=True,
case_id=case_id,
user_id='whatever',
update={
'foo': 'bar'
}).as_xml()
],
domain="test-domain")
CommCareCase.objects.soft_delete_cases("test-domain", [case_id])
case = CommCareCase.objects.get_case(case_id, "test-domain")
self.assertEqual('bar', case.dynamic_case_properties()['foo'])
self.assertTrue(case.is_deleted)
xform, [case] = post_case_blocks([
CaseBlock(create=False,
case_id=case_id,
user_id='whatever',
update={
'foo': 'not_bar'
}).as_xml()
])
self.assertEqual('not_bar', case.dynamic_case_properties()['foo'])
self.assertTrue(case.is_deleted)
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()
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 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,
)
post_case_blocks([case_block], {'domain': self.domain})
check_has_block(case_block, should_have, should_not_have, line_by_line=False)
def _update_episode_case(domain, case_id, updated_properties):
post_case_blocks(
[CaseBlock(
case_id=case_id,
update=updated_properties
).as_xml()],
{'domain': domain}
)
def testBadIndexReference(self):
block = CaseBlock(create=True, case_id=self.CASE_ID, user_id=USER_ID, version=V2,
index={'bad': ('bad-case', 'not-an-existing-id')})
try:
post_case_blocks([block.as_xml()])
self.fail("Submitting against a bad case in an index should fail!")
except IllegalCaseId:
pass
def create_and_test(case_id, user, owner, should_have, should_not_have, version):
case_block = self.get_create_block(
case_id=case_id, type="case", user_id=user.user_id, owner_id=owner.get_id, version=version
)
post_case_blocks([case_block], {"domain": self.domain})
CommCareCase.get(case_id)
check_has_block(case_block, should_have, should_not_have, version=version)
def update_case(domain, case_id, updated_properties, external_id=None):
kwargs = {
'case_id': case_id,
'update': updated_properties,
}
if external_id is not None:
kwargs.update({'external_id': external_id})
post_case_blocks([CaseBlock(**kwargs).as_xml()], {'domain': domain})
def create_case(self):
case_block = CaseBlock(
create=True,
case_id=self.host_case_id,
case_name=self.host_case_name,
case_type=self.host_case_type,
owner_id="not the user",
).as_xml()
post_case_blocks([case_block], {'domain': DOMAIN})
def update_case_owner(self, case, owner):
case_block = CaseBlock(
create=False,
case_id=case.case_id,
case_type='participant',
owner_id=owner.get_id,
user_id=owner.get_id,
).as_xml()
post_case_blocks([case_block], {'domain': self.domain})
def create_case(self):
case_block = CaseBlock.deprecated_init(
create=True,
case_id=self.host_case_id,
case_name=self.host_case_name,
case_type=self.host_case_type,
owner_id='in_soviet_russia_the_case_owns_you',
).as_xml()
post_case_blocks([case_block], {'domain': 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,
)
post_case_blocks([case_block], {'domain': self.domain})
check_has_block(case_block, should_have, should_not_have)
def add_parent_access(self, user, case):
case_block = CaseBlock(
create=True,
case_id=uuid.uuid4().hex,
case_type='magic_map',
owner_id=user.get_id,
index={'parent': ('participant', case.case_id)}
).as_xml()
post_case_blocks([case_block], {'domain': self.domain})
def add_parent_access(self, user, case):
case_block = CaseBlock(create=True,
case_id=uuid.uuid4().hex,
case_type='magic_map',
owner_id=user.get_id,
index={
'parent': ('participant', case.case_id)
}).as_xml()
post_case_blocks([case_block], {'domain': self.domain})
def create_case(self):
case_block = CaseBlock(
create=True,
case_id=self.host_case_id,
case_name=self.host_case_name,
case_type=self.host_case_type,
owner_id='in_soviet_russia_the_case_owns_you',
).as_xml()
post_case_blocks([case_block], {'domain': DOMAIN})
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,
version=V2,
index={'parent': ('participant', case._id)}
).as_xml(format_datetime=json_format_datetime)
post_case_blocks([case_block], {'domain': self.domain})
def update_and_test(case_id, owner=None, should_have=None, should_not_have=None, version=V1):
case_block = self.get_update_block(
case_id='case-a-1',
update={'greeting': "Hello!"},
owner_id=owner.get_id if owner else None,
version=version
)
post_case_blocks([case_block])
check_has_block(case_block, should_have, should_not_have, line_by_line=False, version=version)
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,
version=V2
).as_xml(format_datetime=json_format_datetime)
post_case_blocks([case_block], {'domain': self.domain})
def update_and_test(case_id, owner=None, should_have=None, should_not_have=None, version=V1):
case_block = self.get_update_block(
case_id="case-a-1",
update={"greeting": "Hello!"},
owner_id=owner.get_id if owner else None,
version=version,
)
post_case_blocks([case_block], {"domain": self.domain})
check_has_block(case_block, should_have, should_not_have, line_by_line=False, version=version)
def _new_case(self, properties):
id = uuid.uuid4().hex
case_block = CaseBlock(
create=True,
case_id=id,
case_type=self.case_type,
update=properties,
).as_xml()
post_case_blocks([case_block], {'domain': self.domain})
return CommCareCase.get(id)
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()
post_case_blocks([case_block], {'domain': cls.domain})
return CommCareCase.get(id)
def _create_case(cls, parent_id):
case_id = uuid.uuid4().hex
caseblock = CaseBlock(case_id=case_id,
case_type=cls.case_type,
date_opened=cls.case_date_opened,
case_name=cls.case_name,
update=cls._get_case_property_values(),
index={'parent': (cls.case_type, parent_id)})
post_case_blocks([caseblock.as_xml()], domain=cls.domain)
return case_id
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()
with drop_connected_signals(case_post_save):
post_case_blocks([case_block], {'domain': cls.domain})
return CommCareCase.get(id)
def _new_case(cls, properties):
id = uuid.uuid4().hex
case_block = CaseBlock(
create=True,
case_id=id,
case_type=cls.case_type,
version=V2,
update=properties,
).as_xml()
post_case_blocks([case_block], {'domain': cls.domain})
return CommCareCase.get(id)
def _make_some_cases(howmany, domain='dbcache-test'):
ids = [uuid.uuid4().hex for i in range(howmany)]
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 testRelationshipGetsSet(self):
create_index = CaseBlock(
create=True,
case_id=self.CASE_ID,
user_id=self.user.user_id,
owner_id=self.user.user_id,
index={'mom': ('mother-case', self.MOTHER_CASE_ID, 'extension')},
).as_xml()
post_case_blocks([create_index], domain=self.project.name)
check_user_has_case(self, self.user, create_index)
def _new_case(self, properties):
id = uuid.uuid4().hex
case_block = CaseBlock(
create=True,
case_id=id,
case_type=self.case_type,
update=properties,
).as_xml()
post_case_blocks([case_block], {'domain': self.domain})
case = CommCareCase.get(id)
self.addCleanup(case.delete)
return case
def _new_case(self, properties):
id = uuid.uuid4().hex
case_block = CaseBlock.deprecated_init(
create=True,
case_id=id,
case_type=self.case_type,
update=properties,
).as_xml()
post_case_blocks([case_block], {'domain': self.domain})
case = CommCareCase.get(id)
self.addCleanup(case.delete)
return case
def _create_closed_case(cls):
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
case_id=case_id,
case_type=cls.case_type,
date_opened=cls.closed_case_date_opened,
date_modified=cls.closed_case_date_closed,
case_name=cls.case_name,
close=True,
)
post_case_blocks([caseblock.as_xml()], domain=cls.domain)
return case_id
def _create_parent_case(cls, case_name):
parent_id = uuid.uuid4().hex
post_case_blocks([
CaseBlock.deprecated_init(
create=True,
case_id=parent_id,
case_name=case_name,
case_type=cls.parent_case_type,
).as_xml()
],
domain=cls.domain)
return parent_id
def testBadIndexReference(self):
CASE_ID = 'test-bad-index-case'
block = CaseBlock(create=True,
case_id=CASE_ID,
user_id=USER_ID,
version=V2,
index={'bad': ('bad-case', 'not-an-existing-id')})
try:
post_case_blocks([block.as_xml()])
self.fail("Submitting against a bad case in an index should fail!")
except IllegalCaseId:
pass
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()
post_case_blocks([create_index])
check_user_has_case(self, user, create_index)
def create_and_test(case_id, user, owner, should_have, should_not_have, version):
case_block = self.get_create_block(
case_id=case_id,
type="case",
user_id=user.user_id,
owner_id=owner.get_id,
version=version
)
post_case_blocks([case_block], {'domain': self.domain})
CommCareCase.get(case_id)
check_has_block(case_block, should_have, should_not_have, version=version)
def _make_case(self, user_id, owner_id, **kwargs):
id = uuid.uuid4().hex
case_block = CaseBlock(create=True,
case_id=id,
case_name='Some Name',
case_type='rectest',
user_id=user_id,
owner_id=owner_id,
version=V2,
**kwargs).as_xml()
post_case_blocks([case_block], {'domain': self.domain})
return CommCareCase.get(id)
def _create_closed_case(cls):
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
case_id=case_id,
case_type=cls.case_type,
date_opened=cls.closed_case_date_opened,
date_modified=cls.closed_case_date_closed,
case_name=cls.case_name,
close=True,
)
post_case_blocks([caseblock.as_xml()], domain=cls.domain)
return case_id
def testParseWithIndices(self):
self._test_parse_create()
user_id = "bar-user-id"
for prereq in ["some_referenced_id", "some_other_referenced_id"]:
post_case_blocks([
CaseBlock(create=True, case_id=prereq,
user_id=user_id).as_xml()
])
file_path = os.path.join(os.path.dirname(__file__), "data", "v2",
"index_update.xml")
with open(file_path, "rb") as f:
xml_data = f.read()
case = submit_form_locally(xml_data, 'test-domain').case
self.assertEqual(2, len(case.indices))
self.assertTrue(case.has_index("foo_ref"))
self.assertTrue(case.has_index("baz_ref"))
self.assertEqual("bar", case.get_index("foo_ref").referenced_type)
self.assertEqual("some_referenced_id",
case.get_index("foo_ref").referenced_id)
self.assertEqual("bop", case.get_index("baz_ref").referenced_type)
self.assertEqual("some_other_referenced_id",
case.get_index("baz_ref").referenced_id)
if not getattr(settings, 'TESTS_SHOULD_USE_SQL_BACKEND', False):
# check the action
self.assertEqual(2, len(case.actions))
[_, index_action] = case.actions
self.assertEqual(const.CASE_ACTION_INDEX, index_action.action_type)
self.assertEqual(2, len(index_action.indices))
# quick test for ota restore
v2response = xml.get_case_xml(
case, [const.CASE_ACTION_CREATE, const.CASE_ACTION_UPDATE], V2)
expected_v2_response = """
<case case_id="foo-case-id" date_modified="2011-12-07T13:42:50.000000Z" user_id="bar-user-id" xmlns="http://commcarehq.org/case/transaction/v2">
<create>
<case_type>v2_case_type</case_type>
<case_name>test case name</case_name>
<owner_id>bar-user-id</owner_id>
</create>
<update>
<date_opened>2011-12-06</date_opened>
</update>
<index>
<baz_ref case_type="bop">some_other_referenced_id</baz_ref>
<foo_ref case_type="bar">some_referenced_id</foo_ref>
</index>
</case>"""
check_xml_line_by_line(self, expected_v2_response, v2response)
def _create_parent_case(cls, case_name):
parent_id = uuid.uuid4().hex
post_case_blocks(
[
CaseBlock(
create=True,
case_id=parent_id,
case_name=case_name,
case_type=cls.parent_case_type,
).as_xml()
], domain=cls.domain
)
return parent_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,
version=V2,
index=index,
).as_xml(format_datetime=json_format_datetime)
post_case_blocks([case_block], {'domain': self.domain})
return CommCareCase.get(id)
def _make_case(self, user_id, owner_id, **kwargs):
id = uuid.uuid4().hex
case_block = CaseBlock(
create=True,
case_id=id,
case_name='Some Name',
case_type='rectest',
user_id=user_id,
owner_id=owner_id,
**kwargs
).as_xml()
post_case_blocks([case_block], {'domain': self.domain})
return CommCareCase.get(id)
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,
version=V2,
).as_xml(format_datetime=json_format_datetime)
post_case_blocks([case_block], {'domain': domain})
return CommCareCase.get(case_id)
def _make_some_cases(howmany, domain='dbcache-test'):
ids = [uuid.uuid4().hex for i in range(howmany)]
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
