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)