def testOtherUserUpdatesUnowned(self):
# create a case from one user and assign ownership elsewhere
case_id = "other_user_updates_unowned"
self._createCaseStubs([case_id], owner_id=OTHER_USER_ID)
# sync and update from another user
check_user_has_case(self, self.other_user,
CaseBlock(case_id=case_id, version=V2).as_xml(),
should_have=True, line_by_line=False,
restore_id=self.other_sync_log.get_id, version=V2)
self.other_sync_log = SyncLog.last_for_user(OTHER_USER_ID)
update = CaseBlock(
create=False,
case_id=case_id,
user_id=OTHER_USER_ID,
version=V2,
update={'greeting': 'hello'}
).as_xml()
self._postFakeWithSyncToken(
update,
self.other_sync_log.get_id
)
# original user syncs again
# make sure there are no new changes
# sync and update from another user
check_user_has_case(self, self.user, update, should_have=False,
restore_id=self.sync_log.get_id, version=V2)
def testOtherUserEdits(self):
# create a case by one user
case_id = "other_user_edits"
self._createCaseStubs([case_id], owner_id=SHARED_ID)
# sync to the other's phone to be able to edit
check_user_has_case(self, self.other_user,
CaseBlock(case_id=case_id, version=V2).as_xml(),
should_have=True, line_by_line=False,
restore_id=self.other_sync_log.get_id, version=V2)
latest_sync = SyncLog.last_for_user(OTHER_USER_ID)
# update from another
self._postFakeWithSyncToken(
CaseBlock(create=False, case_id=case_id, user_id=OTHER_USER_ID,
version=V2, update={'greeting': "Hello!"}
).as_xml(), latest_sync.get_id)
# original user syncs again
# make sure updates take
updated_case = CaseBlock(create=False, case_id=case_id, user_id=USER_ID,
version=V2, update={'greeting': "Hello!"}).as_xml()
match = check_user_has_case(self, self.user, updated_case, should_have=True,
line_by_line=False, restore_id=self.sync_log.get_id,
version=V2)
self.assertTrue("Hello!" in ElementTree.tostring(match))
def testOtherUserAddsIndex(self):
time = datetime.utcnow()
# create a case from one user
case_id = "other_user_adds_index"
self._createCaseStubs([case_id], owner_id=SHARED_ID)
# sync to the other's phone to be able to edit
assert_user_has_case(self, self.other_user, case_id, restore_id=self.other_sync_log.get_id)
latest_sync = SyncLog.last_for_user(OTHER_USER_ID)
mother_id = "other_user_adds_index_mother"
parent_case = CaseBlock(
create=True,
date_modified=time,
case_id=mother_id,
user_id=OTHER_USER_ID,
case_type=PARENT_TYPE,
version=V2,
).as_xml(format_datetime=json_format_datetime)
self._postFakeWithSyncToken(
parent_case,
latest_sync.get_id
)
# the original user should not get the parent case
assert_user_doesnt_have_case(self, self.user, mother_id, restore_id=self.sync_log.get_id)
# update the original case from another, adding an indexed case
self._postFakeWithSyncToken(
CaseBlock(
create=False,
case_id=case_id,
user_id=OTHER_USER_ID,
owner_id=USER_ID,
version=V2,
index={'mother': ('mother', mother_id)}
).as_xml(format_datetime=json_format_datetime),
latest_sync.get_id
)
# original user syncs again
# make sure index updates take and indexed case also syncs
expected_parent_case = CaseBlock(
create=True,
date_modified=time,
case_id=mother_id,
user_id=OTHER_USER_ID,
case_type=PARENT_TYPE,
owner_id=OTHER_USER_ID,
version=V2,
).as_xml(format_datetime=json_format_datetime)
check_user_has_case(self, self.user, expected_parent_case,
restore_id=self.sync_log.get_id, version=V2,
purge_restore_cache=True)
_, orig = assert_user_has_case(self, self.user, case_id, restore_id=self.sync_log.get_id)
self.assertTrue("index" in ElementTree.tostring(orig))
def testMultiUserEdits(self):
time = datetime.now()
# create a case from one user
case_id = "multi_user_edits"
self._createCaseStubs([case_id], owner_id=SHARED_ID)
# both users syncs
self.sync_log = synclog_from_restore_payload(generate_restore_payload(self.user))
self.other_sync_log = synclog_from_restore_payload(generate_restore_payload(self.other_user))
# update case from same user
my_change = CaseBlock(
create=False,
date_modified=time,
case_id=case_id,
user_id=USER_ID,
version=V2,
update={'greeting': 'hello'}
).as_xml(format_datetime=json_format_datetime)
self._postFakeWithSyncToken(
my_change,
self.sync_log.get_id
)
# update from another user
their_change = CaseBlock(
create=False,
date_modified=time,
case_id=case_id,
user_id=USER_ID,
version=V2,
update={'greeting_2': 'hello'}
).as_xml(format_datetime=json_format_datetime)
self._postFakeWithSyncToken(
their_change,
self.other_sync_log.get_id
)
# original user syncs again
# make sure updates both appear (and merge?)
joint_change = CaseBlock(
create=False,
date_modified=time,
case_id=case_id,
user_id=USER_ID,
version=V2,
update={
'greeting': 'hello',
'greeting_2': 'hello'
},
owner_id=SHARED_ID,
case_name='',
case_type='mother',
).as_xml(format_datetime=json_format_datetime)
check_user_has_case(self, self.user, joint_change, restore_id=self.sync_log.get_id, version=V2)
check_user_has_case(self, self.other_user, joint_change, restore_id=self.other_sync_log.get_id, version=V2)
def testSharedCase(self):
# create a case by one user
case_id = "shared_case"
self._createCaseStubs([case_id], owner_id=SHARED_ID)
# should sync to the other owner
expected = CaseBlock(case_id=case_id, version=V2).as_xml()
check_user_has_case(self, self.other_user, expected, should_have=True,
line_by_line=False,
restore_id=self.other_sync_log.get_id, version=V2)
def testStockSyncToken(self):
# first restore should not have the updated case
check_user_has_case(self, self.casexml_user, self.sp_block, should_have=False,
restore_id=self.sync_log_id, version=V2)
# submit with token
amounts = [(p._id, float(i*10)) for i, p in enumerate(self.products)]
self.submit_xml_form(balance_submission(amounts), last_sync_token=self.sync_log_id)
# now restore should have the case
check_user_has_case(self, self.casexml_user, self.sp_block, should_have=True,
restore_id=self.sync_log_id, version=V2, line_by_line=False)
def testStockSyncToken(self):
# first restore should not have the updated case
check_user_has_case(self, self.restore_user, self.sp_block, should_have=False,
restore_id=self.sync_log_id, version=V2)
# submit with token
amounts = [(p._id, float(i*10)) for i, p in enumerate(self.products)]
self.submit_xml_form(balance_submission(amounts), last_sync_token=self.sync_log_id)
# now restore should have the case
check_user_has_case(self, self.restore_user, self.sp_block, should_have=True,
restore_id=self.sync_log_id, version=V2, line_by_line=False)
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 check_supply_point(self, user, sp, should_have=True):
caseblock = CaseBlock(
create=False,
case_id=sp,
version=V2,
).as_xml()
check_user_has_case(self,
user.to_casexml_user(),
caseblock,
line_by_line=False,
should_have=should_have,
version=V2)
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 check_supply_point(self, user, sp, should_have=True):
caseblock = CaseBlock(
create=False,
case_id=sp,
).as_xml()
check_user_has_case(
self,
user.to_ota_restore_user(),
caseblock,
line_by_line=False,
should_have=should_have,
)
def check_supply_point(self, user, sp, should_have=True):
caseblock = CaseBlock(
create=False,
case_id=sp,
).as_xml()
check_user_has_case(
self,
user.to_casexml_user(),
caseblock,
line_by_line=False,
should_have=should_have,
)
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 check_has_block(case_block, should_have, should_not_have, line_by_line=True, version=V1):
for user in should_have:
check_user_has_case(
self, user.to_casexml_user(), case_block, line_by_line=line_by_line, version=version
)
for user in should_not_have:
check_user_has_case(
self,
user.to_casexml_user(),
case_block,
should_have=False,
line_by_line=line_by_line,
version=version,
)
def check_supply_point(self, user, sp, should_have=True):
caseblock = CaseBlock(
create=False,
case_id=sp,
version=V2,
).as_xml(format_datetime=json_format_datetime)
check_user_has_case(
self,
user.to_casexml_user(),
caseblock,
line_by_line=False,
should_have=should_have,
version=V2
)
def testRelationshipGetsSet(self):
parent_case_id = uuid.uuid4().hex
post_case_blocks(
[CaseBlock(create=True, case_id=parent_case_id, user_id=self.user.user_id).as_xml()],
domain=self.project.name
)
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', parent_case_id, 'extension')},
).as_xml()
post_case_blocks([create_index], domain=self.project.name)
check_user_has_case(self, self.user, create_index)
def testOtherUserAddsIndex(self):
# create a case from one user
case_id = "other_user_adds_index"
self._createCaseStubs([case_id], owner_id=SHARED_ID)
# sync to the other's phone to be able to edit
check_user_has_case(self, self.other_user,
CaseBlock(case_id=case_id, version=V2).as_xml(),
should_have=True, line_by_line=False,
restore_id=self.other_sync_log.get_id, version=V2)
latest_sync = SyncLog.last_for_user(OTHER_USER_ID)
mother_id = "other_user_adds_index_mother"
# parent case
parent_case = CaseBlock(
create=True,
case_id=mother_id,
user_id=OTHER_USER_ID,
case_type=PARENT_TYPE,
version=V2,
).as_xml()
self._postFakeWithSyncToken(
parent_case,
latest_sync.get_id
)
# the original user should not get the parent case
check_user_has_case(self, self.user, parent_case, should_have=False,
restore_id=self.sync_log.get_id, version=V2)
# update the original case from another, adding an indexed case
self._postFakeWithSyncToken(
CaseBlock(
create=False,
case_id=case_id,
user_id=OTHER_USER_ID,
owner_id=USER_ID,
version=V2,
index={'mother': ('mother', mother_id)}
).as_xml(),
latest_sync.get_id
)
# original user syncs again
# make sure index updates take and indexed case also syncs
expected_parent_case = CaseBlock(
create=True,
case_id=mother_id,
user_id=OTHER_USER_ID,
case_type=PARENT_TYPE,
owner_id=OTHER_USER_ID,
version=V2,
).as_xml()
check_user_has_case(self, self.user, expected_parent_case,
restore_id=self.sync_log.get_id, version=V2)
orig = check_user_has_case(self, self.user, CaseBlock(case_id=case_id, version=V2).as_xml(),
line_by_line=False, restore_id=self.sync_log.get_id,
version=V2)
self.assertTrue("index" in ElementTree.tostring(orig))
def check_has_block(case_block,
should_have,
should_not_have,
line_by_line=True,
version=V1):
for user in should_have:
check_user_has_case(self,
user.to_casexml_user(),
case_block,
line_by_line=line_by_line,
version=version)
for user in should_not_have:
check_user_has_case(self,
user.to_casexml_user(),
case_block,
should_have=False,
line_by_line=line_by_line,
version=version)
def testRelationshipGetsSet(self):
parent_case_id = uuid.uuid4().hex
post_case_blocks([
CaseBlock(create=True,
case_id=parent_case_id,
user_id=self.user.user_id).as_xml()
],
domain=self.project.name)
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', parent_case_id, 'extension')
},
).as_xml()
post_case_blocks([create_index], domain=self.project.name)
check_user_has_case(self, self.user, create_index)
def test_date_opened_coercion(self):
delete_all_users()
self.project = Domain(name='some-domain')
self.project.save()
user = create_restore_user(self.project.name)
case_id = uuid.uuid4().hex
modified_on = datetime.utcnow()
case = CaseBlock(
create=True,
case_id=case_id,
user_id=user.user_id, owner_id=user.user_id, case_type='demo',
case_name='create_case', date_modified=modified_on, date_opened=modified_on, update={
'dynamic': '123'
}
)
post_case_blocks([case.as_xml()], domain='some-domain')
# update the date_opened to date type to check for value on restore
case.date_opened = case.date_opened.date()
check_user_has_case(self, user, case.as_xml())
def testClosedParentIndex(self):
"""
Tests that things work properly when you have a reference to the parent
case in a child, even if it's closed.
"""
# first create the parent case
parent_id = "mommy"
self._createCaseStubs([parent_id])
self._testUpdate(self.sync_log.get_id, {parent_id: []})
# create the child
child_id = "baby"
index_id = 'my_mom_is'
child = CaseBlock(
create=True,
case_id=child_id,
user_id=USER_ID,
version=V2,
index={index_id: (PARENT_TYPE, parent_id)},
).as_xml()
self._postFakeWithSyncToken(child, self.sync_log.get_id)
index_ref = CommCareCaseIndex(identifier=index_id,
referenced_type=PARENT_TYPE,
referenced_id=parent_id)
self._testUpdate(self.sync_log.get_id, {parent_id: [],
child_id: [index_ref]})
# close the mother case
close = CaseBlock(create=False, case_id=parent_id, user_id=USER_ID,
version=V2, close=True
).as_xml()
self._postFakeWithSyncToken(close, self.sync_log.get_id)
self._testUpdate(self.sync_log.get_id, {child_id: [index_ref]},
{parent_id: []})
# try a clean restore again
check_user_has_case(self, self.user, close, should_have=True,
version=V2, line_by_line=False)
check_user_has_case(self, self.user, child, should_have=True,
version=V2, line_by_line=False)
def testOwnUpdatesDontSync(self):
case_id = "own_updates_dont_sync"
self._createCaseStubs([case_id])
case_block = CaseBlock(
create=True,
case_id=case_id,
user_id=USER_ID,
version=V2,
).as_xml()
check_user_has_case(self, self.user, case_block, should_have=False,
restore_id=self.sync_log.get_id, version=V2)
update_block = CaseBlock(
create=False,
case_id=case_id,
user_id=USER_ID,
version=V2,
update={"greeting": "hello"}
).as_xml()
self._postFakeWithSyncToken(update_block, self.sync_log.get_id)
check_user_has_case(self, self.user, update_block, should_have=False,
restore_id=self.sync_log.get_id, version=V2)
reassign_block = CaseBlock(
create=False,
case_id=case_id,
owner_id=OTHER_USER_ID,
version=V2
).as_xml()
self._postFakeWithSyncToken(reassign_block, self.sync_log.get_id)
check_user_has_case(self, self.user, reassign_block, should_have=False,
restore_id=self.sync_log.get_id, version=V2)
def testOtherUserCloses(self):
# create a case from one user
case_id = "other_user_closes"
self._createCaseStubs([case_id], owner_id=SHARED_ID)
# sync then close case from another user
generate_restore_payload(self.other_user)
self.other_sync_log = SyncLog.last_for_user(OTHER_USER_ID)
close_block = CaseBlock(
create=False,
case_id=case_id,
user_id=USER_ID,
version=V2,
close=True
).as_xml()
self._postFakeWithSyncToken(
close_block,
self.other_sync_log.get_id
)
# original user syncs again
# make sure close block appears
check_user_has_case(self, self.user, close_block, line_by_line=False,
restore_id=self.sync_log.get_id, version=V2)
def testIndexesSync(self):
# create a parent and child case (with index) from one user
parent_id = "indexes_sync_parent"
case_id = "indexes_sync"
self._createCaseStubs([parent_id])
child = CaseBlock(
create=True,
case_id=case_id,
user_id=USER_ID,
owner_id=USER_ID,
version=V2,
index={'mother': ('mother', parent_id)}
).as_xml()
self._postFakeWithSyncToken(child, self.sync_log.get_id)
# make sure the second user doesn't get either
parent = CaseBlock(case_id=parent_id, version=V2).as_xml()
child = CaseBlock(case_id=case_id, version=V2).as_xml()
check_user_has_case(self, self.other_user, parent, should_have=False,
restore_id=self.other_sync_log.get_id, version=V2)
check_user_has_case(self, self.other_user, child, should_have=False,
restore_id=self.other_sync_log.get_id, version=V2)
# assign just the child case to a second user
child_update = CaseBlock(
create=False,
case_id=case_id,
user_id=USER_ID,
owner_id=OTHER_USER_ID,
version=V2,
update={"greeting": "hello"}
).as_xml()
self._postFakeWithSyncToken(child_update, self.sync_log.get_id)
# second user syncs
# make sure both cases restore
check_user_has_case(self, self.other_user, parent, should_have=True,
line_by_line=False,
restore_id=self.other_sync_log.get_id, version=V2)
check_user_has_case(self, self.other_user, child, should_have=True,
line_by_line=False,
restore_id=self.other_sync_log.get_id, version=V2)
def check_has_block(case_block, should_have, should_not_have, line_by_line=True):
for user in should_have:
check_user_has_case(self, user.to_ota_restore_user(), case_block, line_by_line=line_by_line)
for user in should_not_have:
check_user_has_case(self, user.to_ota_restore_user(), case_block, should_have=False, line_by_line=line_by_line)
def testOtherUserAddsIndex(self):
time = datetime.now()
# create a case from one user
case_id = "other_user_adds_index"
self._createCaseStubs([case_id], owner_id=SHARED_ID)
# sync to the other's phone to be able to edit
assert_user_has_case(self,
self.other_user,
case_id,
restore_id=self.other_sync_log.get_id)
latest_sync = SyncLog.last_for_user(OTHER_USER_ID)
mother_id = "other_user_adds_index_mother"
parent_case = CaseBlock(
create=True,
date_modified=time,
case_id=mother_id,
user_id=OTHER_USER_ID,
case_type=PARENT_TYPE,
version=V2,
).as_xml(format_datetime=json_format_datetime)
self._postFakeWithSyncToken(parent_case, latest_sync.get_id)
# the original user should not get the parent case
assert_user_doesnt_have_case(self,
self.user,
mother_id,
restore_id=self.sync_log.get_id)
# update the original case from another, adding an indexed case
self._postFakeWithSyncToken(
CaseBlock(create=False,
case_id=case_id,
user_id=OTHER_USER_ID,
owner_id=USER_ID,
version=V2,
index={
'mother': ('mother', mother_id)
}).as_xml(format_datetime=json_format_datetime),
latest_sync.get_id)
# original user syncs again
# make sure index updates take and indexed case also syncs
expected_parent_case = CaseBlock(
create=True,
date_modified=time,
case_id=mother_id,
user_id=OTHER_USER_ID,
case_type=PARENT_TYPE,
owner_id=OTHER_USER_ID,
version=V2,
).as_xml(format_datetime=json_format_datetime)
check_user_has_case(self,
self.user,
expected_parent_case,
restore_id=self.sync_log.get_id,
version=V2)
orig = assert_user_has_case(self,
self.user,
case_id,
restore_id=self.sync_log.get_id)
self.assertTrue("index" in ElementTree.tostring(orig))
def testMultiUserEdits(self):
time = datetime.now()
# create a case from one user
case_id = "multi_user_edits"
self._createCaseStubs([case_id], owner_id=SHARED_ID)
# both users syncs
self.sync_log = synclog_from_restore_payload(
generate_restore_payload(self.user))
self.other_sync_log = synclog_from_restore_payload(
generate_restore_payload(self.other_user))
# update case from same user
my_change = CaseBlock(create=False,
date_modified=time,
case_id=case_id,
user_id=USER_ID,
version=V2,
update={
'greeting': 'hello'
}).as_xml(format_datetime=json_format_datetime)
self._postFakeWithSyncToken(my_change, self.sync_log.get_id)
# update from another user
their_change = CaseBlock(
create=False,
date_modified=time,
case_id=case_id,
user_id=USER_ID,
version=V2,
update={
'greeting_2': 'hello'
}).as_xml(format_datetime=json_format_datetime)
self._postFakeWithSyncToken(their_change, self.other_sync_log.get_id)
# original user syncs again
# make sure updates both appear (and merge?)
joint_change = CaseBlock(
create=False,
date_modified=time,
case_id=case_id,
user_id=USER_ID,
version=V2,
update={
'greeting': 'hello',
'greeting_2': 'hello'
},
owner_id=SHARED_ID,
case_name='',
case_type='mother',
).as_xml(format_datetime=json_format_datetime)
check_user_has_case(self,
self.user,
joint_change,
restore_id=self.sync_log.get_id,
version=V2)
check_user_has_case(self,
self.other_user,
joint_change,
restore_id=self.other_sync_log.get_id,
version=V2)
def testIndexes(self):
# Step 0. Create mother and father cases
for prereq in [self.MOTHER_CASE_ID, self.FATHER_CASE_ID]:
post_case_blocks(
[CaseBlock(create=True, case_id=prereq, user_id=self.user.user_id).as_xml()],
domain=self.project.name
)
# Step 1. Create a case with index <mom>
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)},
).as_xml()
post_case_blocks([create_index], domain=self.project.name)
check_user_has_case(self, 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=self.user.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=self.user.user_id,
owner_id=self.user.user_id,
create=True,
index={'dad': ('father-case', self.FATHER_CASE_ID)},
date_modified=now,
).as_xml()
post_case_blocks([update_index], domain=self.project.name)
check_user_has_case(self, self.user, update_index_expected)
# Step 3. Put <mom> back
now = datetime.datetime.utcnow()
update_index = CaseBlock(
case_id=self.CASE_ID,
user_id=self.user.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=self.user.user_id,
owner_id=self.user.user_id,
create=True,
index={'mom': ('mother-case', self.MOTHER_CASE_ID),
'dad': ('father-case', self.FATHER_CASE_ID)},
date_modified=now,
).as_xml()
post_case_blocks([update_index], domain=self.project.name)
check_user_has_case(self, self.user, update_index_expected)
def testIndexes(self):
# Step 0. Create mother and father cases
for prereq in [self.MOTHER_CASE_ID, self.FATHER_CASE_ID]:
post_case_blocks([
CaseBlock(create=True,
case_id=prereq,
user_id=self.user.user_id).as_xml()
],
domain=self.project.name)
now = datetime.datetime.utcnow()
# Step 1. Create a case with index <mom>
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)
},
).as_xml()
post_case_blocks([create_index], domain=self.project.name)
check_user_has_case(self, 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=self.user.user_id,
index={
'mom': ('mother-case', ''),
'dad':
('father-case', self.FATHER_CASE_ID)
},
date_modified=now,
date_opened=now.date()).as_xml()
update_index_expected = CaseBlock(case_id=self.CASE_ID,
user_id=self.user.user_id,
owner_id=self.user.user_id,
create=True,
index={
'dad': ('father-case',
self.FATHER_CASE_ID)
},
date_modified=now,
date_opened=now.date()).as_xml()
post_case_blocks([update_index], domain=self.project.name)
check_user_has_case(self, self.user, update_index_expected)
# Step 3. Put <mom> back
update_index = CaseBlock(case_id=self.CASE_ID,
user_id=self.user.user_id,
index={
'mom':
('mother-case', self.MOTHER_CASE_ID)
},
date_modified=now,
date_opened=now.date()).as_xml()
update_index_expected = CaseBlock(case_id=self.CASE_ID,
user_id=self.user.user_id,
owner_id=self.user.user_id,
create=True,
index={
'mom': ('mother-case',
self.MOTHER_CASE_ID),
'dad': ('father-case',
self.FATHER_CASE_ID)
},
date_modified=now,
date_opened=now.date()).as_xml()
post_case_blocks([update_index], domain=self.project.name)
check_user_has_case(self, self.user, update_index_expected)
def testIndexes(self):
CASE_ID = 'test-index-case'
MOTHER_CASE_ID = 'text-index-mother-case'
FATHER_CASE_ID = 'text-index-father-case'
user = User(user_id=USER_ID, username="", password="", date_joined="")
# Step 0. Create mother and father cases
for prereq in [MOTHER_CASE_ID, FATHER_CASE_ID]:
post_case_blocks([
CaseBlock(create=True,
case_id=prereq,
user_id=USER_ID,
version=V2).as_xml()
])
# Step 1. Create a case with index <mom>
create_index = CaseBlock(
create=True,
case_id=CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
index={
'mom': ('mother-case', MOTHER_CASE_ID)
},
version=V2).as_xml(format_datetime=json_format_datetime)
post_case_blocks([create_index])
check_user_has_case(self, user, create_index, version=V2)
# Step 2. Update the case to delete <mom> and create <dad>
now = datetime.datetime.utcnow()
update_index = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
index={
'mom': ('mother-case', ''),
'dad': ('father-case', FATHER_CASE_ID)
},
version=V2,
date_modified=now,
).as_xml(format_datetime=json_format_datetime)
update_index_expected = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
create=True,
index={
'dad': ('father-case', FATHER_CASE_ID)
},
version=V2,
date_modified=now,
).as_xml(format_datetime=json_format_datetime)
post_case_blocks([update_index])
check_user_has_case(self, user, update_index_expected, version=V2)
# Step 3. Put <mom> back
now = datetime.datetime.utcnow()
update_index = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
index={
'mom': ('mother-case', MOTHER_CASE_ID)
},
version=V2,
date_modified=now,
).as_xml(format_datetime=json_format_datetime)
update_index_expected = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
create=True,
index={
'mom': ('mother-case', MOTHER_CASE_ID),
'dad': ('father-case', FATHER_CASE_ID)
},
version=V2,
date_modified=now,
).as_xml(format_datetime=json_format_datetime)
post_case_blocks([update_index])
check_user_has_case(self, user, update_index_expected, version=V2)
def testIndexes(self):
settings.CASEXML_FORCE_DOMAIN_CHECK = False
CASE_ID = 'test-index-case'
MOTHER_CASE_ID = 'text-index-mother-case'
FATHER_CASE_ID = 'text-index-father-case'
user = User(user_id=USER_ID, username="", password="", date_joined="")
# Step 0. Create mother and father cases
for prereq in [MOTHER_CASE_ID, FATHER_CASE_ID]:
post_case_blocks([
CaseBlock(create=True, case_id=prereq, user_id=USER_ID,
version=V2).as_xml()
])
# Step 1. Create a case with index <mom>
create_index = CaseBlock(
create=True,
case_id=CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
index={'mom': ('mother-case', MOTHER_CASE_ID)},
version=V2
).as_xml(format_datetime=json_format_datetime)
post_case_blocks([create_index])
check_user_has_case(self, user, create_index, version=V2)
# Step 2. Update the case to delete <mom> and create <dad>
now = datetime.datetime.utcnow()
update_index = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
index={'mom': ('mother-case', ''), 'dad': ('father-case', FATHER_CASE_ID)},
version=V2,
date_modified=now,
).as_xml(format_datetime=json_format_datetime)
update_index_expected = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
create=True,
index={'dad': ('father-case', FATHER_CASE_ID)},
version=V2,
date_modified=now,
).as_xml(format_datetime=json_format_datetime)
post_case_blocks([update_index])
check_user_has_case(self, user, update_index_expected, version=V2)
# Step 3. Put <mom> back
now = datetime.datetime.utcnow()
update_index = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
index={'mom': ('mother-case', MOTHER_CASE_ID)},
version=V2,
date_modified=now,
).as_xml(format_datetime=json_format_datetime)
update_index_expected = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
create=True,
index={'mom': ('mother-case', MOTHER_CASE_ID),
'dad': ('father-case', FATHER_CASE_ID)},
version=V2,
date_modified=now,
).as_xml(format_datetime=json_format_datetime)
post_case_blocks([update_index])
check_user_has_case(self, user, update_index_expected, version=V2)
def testIndexes(self):
CASE_ID = 'test-index-case'
MOTHER_CASE_ID = 'text-index-mother-case'
FATHER_CASE_ID = 'text-index-father-case'
user = User(user_id=USER_ID, username="", password="", date_joined="")
# Step 0. Create mother and father cases
for prereq in [MOTHER_CASE_ID, FATHER_CASE_ID]:
post_case_blocks([
CaseBlock(create=True, case_id=prereq, user_id=USER_ID,
version=V2).as_xml()
])
# Step 1. Create a case with index <mom>
create_index = CaseBlock(
create=True,
case_id=CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
index={'mom': ('mother-case', MOTHER_CASE_ID)},
version=V2
).as_xml()
post_case_blocks([create_index])
check_user_has_case(self, user, create_index, version=V2)
# Step 2. Update the case to delete <mom> and create <dad>
update_index = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
index={'mom': ('mother-case', ''), 'dad': ('father-case', FATHER_CASE_ID)},
version=V2
).as_xml()
update_index_expected = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
create=True,
index={'dad': ('father-case', FATHER_CASE_ID)},
version=V2
).as_xml()
post_case_blocks([update_index])
check_user_has_case(self, user, update_index_expected, version=V2)
# Step 3. Put <mom> back
update_index = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
index={'mom': ('mother-case', MOTHER_CASE_ID)},
version=V2
).as_xml()
update_index_expected = CaseBlock(
case_id=CASE_ID,
user_id=USER_ID,
owner_id=USER_ID,
create=True,
index={'mom': ('mother-case', MOTHER_CASE_ID), 'dad': ('father-case', FATHER_CASE_ID)},
version=V2
).as_xml()
post_case_blocks([update_index])
check_user_has_case(self, user, update_index_expected, version=V2)
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]:
post_case_blocks([CaseBlock(create=True, case_id=prereq, user_id=USER_ID, version=V2).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)},
version=V2,
).as_xml()
post_case_blocks([create_index])
check_user_has_case(self, user, create_index, version=V2)
# 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)},
version=V2,
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)},
version=V2,
date_modified=now,
).as_xml()
post_case_blocks([update_index])
check_user_has_case(self, user, update_index_expected, version=V2)
# 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)},
version=V2,
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)},
version=V2,
date_modified=now,
).as_xml()
post_case_blocks([update_index])
check_user_has_case(self, user, update_index_expected, version=V2)
def testOtherUserReassignsIndexed(self):
# create a parent and child case (with index) from one user
parent_id = "other_reassigns_index_parent"
case_id = "other_reassigns_index_child"
self._createCaseStubs([parent_id])
child = CaseBlock(
create=True,
case_id=case_id,
user_id=USER_ID,
owner_id=SHARED_ID,
version=V2,
index={'mother': ('mother', parent_id)}
).as_xml()
self._postFakeWithSyncToken(child, self.sync_log.get_id)
# assign the parent case away from the same user
parent_update = CaseBlock(
create=False,
case_id=parent_id,
user_id=USER_ID,
owner_id=OTHER_USER_ID,
update={"greeting": "hello"},
version=V2).as_xml()
self._postFakeWithSyncToken(parent_update, self.sync_log.get_id)
# sync cases to second user
generate_restore_payload(self.other_user)
self.other_sync_log = SyncLog.last_for_user(self.other_user.user_id)
# change the child's owner from another user
child_reassignment = CaseBlock(
create=False,
case_id=case_id,
user_id=OTHER_USER_ID,
owner_id=OTHER_USER_ID,
version=V2,
update={"childgreeting": "hi!"},
).as_xml()
self._postFakeWithSyncToken(child_reassignment, self.other_sync_log.get_id)
# also change the parent from the second user
other_parent_update = CaseBlock(
create=False,
case_id=parent_id,
user_id=OTHER_USER_ID,
owner_id=OTHER_USER_ID,
update={"other_greeting": "something new"},
version=V2).as_xml()
self._postFakeWithSyncToken(other_parent_update, self.other_sync_log.get_id)
# original user syncs again
self.sync_log = SyncLog.last_for_user(self.user.user_id)
# both cases should sync to original user with updated ownership / edits
check_user_has_case(self, self.user, child_reassignment, should_have=True,
line_by_line=False, restore_id=self.sync_log.get_id,
version=V2)
check_user_has_case(self, self.user, other_parent_update, should_have=True,
line_by_line=False, restore_id=self.sync_log.get_id,
version=V2)
# Ghetto
payload = generate_restore_payload(self.user, self.sync_log.get_id,
version=V2)
self.assertTrue("something new" in payload)
self.assertTrue("hi!" in payload)
# change the parent again from the second user
other_parent_update = CaseBlock(
create=False,
case_id=parent_id,
user_id=OTHER_USER_ID,
owner_id=OTHER_USER_ID,
update={"other_greeting": "something different"},
version=V2).as_xml()
self._postFakeWithSyncToken(other_parent_update, self.other_sync_log.get_id)
# original user syncs again
self.sync_log = SyncLog.last_for_user(self.user.user_id)
# should be no changes
check_user_has_case(self, self.user, child_reassignment, should_have=False,
line_by_line=False, restore_id=self.sync_log.get_id,
version=V2)
check_user_has_case(self, self.user, other_parent_update, should_have=False,
line_by_line=False, restore_id=self.sync_log.get_id,
version=V2)
# change the child again from the second user
other_child_update = CaseBlock(
create=False,
case_id=case_id,
user_id=OTHER_USER_ID,
owner_id=OTHER_USER_ID,
version=V2,
update={"childgreeting": "hi changed!"},
).as_xml()
self._postFakeWithSyncToken(other_child_update, self.other_sync_log.get_id)
# original user syncs again
self.sync_log = SyncLog.last_for_user(self.user.user_id)
# should be no changes
check_user_has_case(self, self.user, other_child_update, should_have=False,
line_by_line=False, restore_id=self.sync_log.get_id,
version=V2)
check_user_has_case(self, self.user, other_parent_update, should_have=False,
line_by_line=False, restore_id=self.sync_log.get_id,
version=V2)
# change owner of child back to orginal user from second user
child_reassignment = CaseBlock(
create=False,
case_id=case_id,
user_id=OTHER_USER_ID,
owner_id=USER_ID,
version=V2
).as_xml()
self._postFakeWithSyncToken(child_reassignment, self.other_sync_log.get_id)
# original user syncs again
self.sync_log = SyncLog.last_for_user(self.user.user_id)
# both cases should now sync
check_user_has_case(self, self.user, child_reassignment, should_have=True,
line_by_line=False, restore_id=self.sync_log.get_id,
version=V2)
check_user_has_case(self, self.user, other_parent_update, should_have=True,
line_by_line=False, restore_id=self.sync_log.get_id,
version=V2)
# ghetto
payload = generate_restore_payload(self.user, self.sync_log.get_id,
version=V2)
self.assertTrue("something different" in payload)
self.assertTrue("hi changed!" in payload)
def testOtherUserUpdatesIndex(self):
# create a parent and child case (with index) from one user
parent_id = "other_updates_index_parent"
case_id = "other_updates_index_child"
self._createCaseStubs([parent_id])
parent = CaseBlock(case_id=parent_id, version=V2).as_xml()
child = CaseBlock(
create=True,
case_id=case_id,
user_id=USER_ID,
owner_id=USER_ID,
version=V2,
index={'mother': ('mother', parent_id)}
).as_xml()
self._postFakeWithSyncToken(child, self.sync_log.get_id)
check_user_has_case(self, self.user, parent, should_have=False,
restore_id=self.sync_log.get_id, version=V2)
check_user_has_case(self, self.user, child, should_have=False,
restore_id=self.sync_log.get_id, version=V2)
# assign the parent case away from same user
parent_update = CaseBlock(
create=False,
case_id=parent_id,
user_id=USER_ID,
owner_id=OTHER_USER_ID,
update={"greeting": "hello"},
version=V2).as_xml()
self._postFakeWithSyncToken(parent_update, self.sync_log.get_id)
self.sync_log = SyncLog.get(self.sync_log.get_id)
# these tests added to debug another issue revealed by this test
self.assertTrue(self.sync_log.phone_has_case(case_id))
self.assertTrue(self.sync_log.phone_has_dependent_case(parent_id))
self.assertTrue(self.sync_log.phone_is_holding_case(case_id))
self.assertTrue(self.sync_log.phone_is_holding_case(parent_id))
# original user syncs again
# make sure there are no new changes
check_user_has_case(self, self.user, parent, should_have=False,
restore_id=self.sync_log.get_id, version=V2)
check_user_has_case(self, self.user, child, should_have=False,
restore_id=self.sync_log.get_id, version=V2)
# update the parent case from another user
check_user_has_case(self, self.other_user, parent, should_have=True,
line_by_line=False,
restore_id=self.other_sync_log.get_id, version=V2)
self.other_sync_log = SyncLog.last_for_user(OTHER_USER_ID)
other_parent_update = CaseBlock(
create=False,
case_id=parent_id,
user_id=OTHER_USER_ID,
update={"greeting2": "hi"},
version=V2
).as_xml()
self._postFakeWithSyncToken(other_parent_update, self.other_sync_log.get_id)
# make sure the indexed case syncs again
self.sync_log = SyncLog.last_for_user(USER_ID)
check_user_has_case(self, self.user, parent, should_have=True,
line_by_line=False,
restore_id=self.sync_log.get_id, version=V2)
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)
