Ejemplo n.º 1
0
 def testOverwriteCache(self):
     restore_payload = generate_restore_payload(
         self.project, dummy_user(), items=True, force_cache=True
     )
     restore_payload_cached = generate_restore_payload(
         self.project, dummy_user(), items=True
     )
     restore_payload_overwrite = generate_restore_payload(
         self.project, dummy_user(), items=True, overwrite_cache=True
     )
     self.assertEqual(restore_payload, restore_payload_cached)
     self.assertNotEqual(restore_payload, restore_payload_overwrite)
Ejemplo n.º 2
0
 def testUserRestoreWithCase(self):
     file_path = os.path.join(os.path.dirname(__file__), "data", "create_short.xml")
     with open(file_path, "rb") as f:
         xml_data = f.read()
     form = post_xform_to_couch(xml_data)
     process_cases(sender="testharness", xform=form)
     user = dummy_user()
     
     # implicit length assertion
     [newcase] = CommCareCase.view("case/by_user", reduce=False, include_docs=True).all()
     self.assertEqual(1, len(user.get_case_updates(None).actual_cases_to_sync))
     expected_case_block = """
     <case>
         <case_id>asdf</case_id> 
         <date_modified>2010-06-29</date_modified>
         <create>
             <case_type_id>test_case_type</case_type_id> 
             <user_id>foo</user_id> 
             <case_name>test case name</case_name> 
             <external_id>someexternal</external_id>
         </create>
     </case>"""
     check_xml_line_by_line(self, expected_case_block, xml.get_case_xml(newcase, [case_const.CASE_ACTION_CREATE,
                                                                                  case_const.CASE_ACTION_UPDATE]))
     
     # check v2
     expected_v2_case_block = """
     <case case_id="asdf" date_modified="2010-06-29" user_id="foo" xmlns="http://commcarehq.org/case/transaction/v2" >
         <create>
             <case_type>test_case_type</case_type> 
             <case_name>test case name</case_name>
             <owner_id>foo</owner_id>
         </create>
         <update>
             <external_id>someexternal</external_id>
         </update>
     </case>"""
     check_xml_line_by_line(self, expected_v2_case_block, xml.get_case_xml\
                            (newcase, [case_const.CASE_ACTION_CREATE,
                                       case_const.CASE_ACTION_UPDATE],
                             version="2.0"))
     
     
     restore_payload = generate_restore_payload(dummy_user())
     # implicit length assertion
     [sync_log] = SyncLog.view("phone/sync_logs_by_user", include_docs=True, reduce=False).all()
     check_xml_line_by_line(self, dummy_restore_xml(sync_log.get_id, expected_case_block), 
                            restore_payload)
Ejemplo n.º 3
0
    def testUserRestoreWithCase(self):
        file_path = os.path.join(os.path.dirname(__file__), "data", "create_short.xml")
        with open(file_path, "rb") as f:
            xml_data = f.read()
        FormProcessorInterface.submit_form_locally(xml_data, self.domain)

        expected_case_block = """
        <case case_id="asdf" date_modified="2010-06-29T13:42:50.000000Z" user_id="foo"
            xmlns="http://commcarehq.org/case/transaction/v2">
            <create>
                <case_type>test_case_type</case_type>
                <case_name>test case name</case_name>
                <owner_id>foo</owner_id>
            </create>
            <update>
                <external_id>someexternal</external_id>
            </update>
        </case>"""

        restore_payload = generate_restore_payload(
            project=Domain(name=self.domain),
            user=dummy_user(),
            items=True,
            version=V3
        )
        sync_log_id = SyncLog.view(
            "phone/sync_logs_by_user",
            include_docs=True,
            reduce=False,
        ).one().get_id
        check_xml_line_by_line(
            self,
            dummy_restore_xml(sync_log_id, expected_case_block, items=4),
            restore_payload
        )
Ejemplo n.º 4
0
    def testUserRestoreWithCase(self):
        file_path = os.path.join(os.path.dirname(__file__),
                                 "data", "create_short.xml")
        with open(file_path, "rb") as f:
            xml_data = f.read()

        # implicit length assertion
        _, _, [newcase] = submit_form_locally(xml_data, domain=self.project.name)

        expected_case_block = """
        <case>
            <case_id>asdf</case_id>
            <date_modified>2010-06-29T13:42:50.000000Z</date_modified>
            <create>
                <case_type_id>test_case_type</case_type_id>
                <user_id>foo</user_id>
                <case_name>test case name</case_name>
                <external_id>someexternal</external_id>
            </create>
        </case>"""
        check_xml_line_by_line(self, expected_case_block, xml.get_case_xml(newcase, [case_const.CASE_ACTION_CREATE,
                                                                                     case_const.CASE_ACTION_UPDATE]))

        # check v2
        expected_v2_case_block = """
        <case case_id="asdf" date_modified="2010-06-29T13:42:50.000000Z" user_id="foo" xmlns="http://commcarehq.org/case/transaction/v2" >
            <create>
                <case_type>test_case_type</case_type>
                <case_name>test case name</case_name>
                <owner_id>foo</owner_id>
            </create>
            <update>
                <external_id>someexternal</external_id>
            </update>
        </case>"""
        check_xml_line_by_line(
            self,
            expected_v2_case_block,
            xml.get_case_xml(
                newcase,
                [case_const.CASE_ACTION_CREATE, case_const.CASE_ACTION_UPDATE],
                version="2.0",
            ),
        )

        restore_payload = generate_restore_payload(
            project=self.project,
            user=dummy_user(),
            items=True,
        )
        sync_log_id = SyncLog.view(
            "phone/sync_logs_by_user",
            include_docs=True,
            reduce=False,
        ).one().get_id
        check_xml_line_by_line(
            self,
            dummy_restore_xml(sync_log_id, expected_case_block, items=4),
            restore_payload
        )
Ejemplo n.º 5
0
 def testSyncToken(self):
     """
     Tests sync token / sync mode support
     """
     
     file_path = os.path.join(os.path.dirname(__file__), "data", "create_short.xml")
     with open(file_path, "rb") as f:
         xml_data = f.read()
     form = post_xform_to_couch(xml_data)
     process_cases(sender="testharness", xform=form)
     
     time.sleep(1)
     restore_payload = generate_restore_payload(dummy_user())
     # implicit length assertion
     [sync_log] = SyncLog.view("phone/sync_logs_by_user", include_docs=True, reduce=False).all()
     check_xml_line_by_line(self, dummy_restore_xml(sync_log.get_id, const.CREATE_SHORT), 
                            restore_payload)
     
     
     time.sleep(1)
     sync_restore_payload = generate_restore_payload(dummy_user(), sync_log.get_id)
     [latest_log] = [log for log in \
                     SyncLog.view("phone/sync_logs_by_user", include_docs=True, reduce=False).all() \
                     if log.get_id != sync_log.get_id]
     
     # should no longer have a case block in the restore XML
     check_xml_line_by_line(self, dummy_restore_xml(latest_log.get_id), 
                            sync_restore_payload)
     
     # apply an update
     time.sleep(1)
     file_path = os.path.join(os.path.dirname(__file__), "data", "update_short.xml")
     with open(file_path, "rb") as f:
         xml_data = f.read()
     form = post_xform_to_couch(xml_data)
     process_cases(sender="testharness", xform=form)
     
     time.sleep(1)
     sync_restore_payload = generate_restore_payload(dummy_user(), latest_log.get_id)
     [even_latest_log] = [log for log in \
                          SyncLog.view("phone/sync_logs_by_user", include_docs=True, reduce=False).all() \
                          if log.get_id != sync_log.get_id and log.get_id != latest_log.get_id]
     
     # case block should come back
     check_xml_line_by_line(self, dummy_restore_xml(even_latest_log.get_id, const.UPDATE_SHORT), 
                            sync_restore_payload)
Ejemplo n.º 6
0
    def testOverwriteCache(self):
        restore_config = get_restore_config(
            self.project, dummy_user(), items=True, force_cache=True
        )
        restore_config_cached = get_restore_config(
            self.project, dummy_user(), items=True
        )
        restore_config_overwrite = get_restore_config(
            self.project, dummy_user(), items=True, overwrite_cache=True
        )
        self.assertNotIsInstance(restore_config.get_payload(), CachedResponse)
        self.assertIsInstance(restore_config_cached.get_payload(), CachedResponse)
        self.assertNotIsInstance(restore_config_overwrite.get_payload(), CachedResponse)

        # even cached responses change the sync log id so they are not the same
        restore_payload = restore_config.get_payload().as_string()
        self.assertNotEqual(restore_payload, restore_config_cached.get_payload().as_string())
        self.assertNotEqual(restore_payload, restore_config_overwrite.get_payload().as_string())
Ejemplo n.º 7
0
 def testUserRestore(self):
     self.assertEqual(0, SyncLog.view(
         "phone/sync_logs_by_user",
         include_docs=True,
         reduce=False,
     ).count())
     restore_payload = generate_restore_payload(self.project, dummy_user(), items=True)
     sync_log = SyncLog.view(
         "phone/sync_logs_by_user",
         include_docs=True,
         reduce=False,
     ).one()
     check_xml_line_by_line(
         self,
         dummy_restore_xml(sync_log.get_id, items=3),
         restore_payload,
     )
Ejemplo n.º 8
0
    def testRestoreAttributes(self):
        file_path = os.path.join(os.path.dirname(__file__),
                                 "data", "attributes.xml")
        with open(file_path, "rb") as f:
            xml_data = f.read()
        _, _, [newcase] = FormProcessorInterface.submit_form_locally(xml_data, domain=self.project.name)

        self.assertTrue(isinstance(newcase.adate, dict))
        self.assertEqual(date(2012, 02, 01), newcase.adate["#text"])
        self.assertEqual("i am an attribute", newcase.adate["@someattr"])
        self.assertTrue(isinstance(newcase.dateattr, dict))
        self.assertEqual("this shouldn't break", newcase.dateattr["#text"])
        self.assertEqual(date(2012, 01, 01), newcase.dateattr["@somedate"])
        self.assertTrue(isinstance(newcase.stringattr, dict))
        self.assertEqual("neither should this", newcase.stringattr["#text"])
        self.assertEqual("i am a string", newcase.stringattr["@somestring"])
        restore_payload = generate_restore_payload(self.project, dummy_user())
        # ghetto
        self.assertTrue('<dateattr somedate="2012-01-01">' in restore_payload)
        self.assertTrue('<stringattr somestring="i am a string">' in restore_payload)
Ejemplo n.º 9
0
 def testRestoreAttributes(self):
     file_path = os.path.join(os.path.dirname(__file__),
                              "data", "attributes.xml")
     with open(file_path, "rb") as f:
         xml_data = f.read()
     form = post_xform_to_couch(xml_data, domain=self.project.name)
     [newcase] = process_cases(form)
     
     self.assertTrue(isinstance(newcase.adate, dict))
     self.assertEqual(date(2012,02,01), newcase.adate["#text"])
     self.assertEqual("i am an attribute", newcase.adate["@someattr"])
     self.assertTrue(isinstance(newcase.dateattr, dict))
     self.assertEqual("this shouldn't break", newcase.dateattr["#text"])
     self.assertEqual(date(2012,01,01), newcase.dateattr["@somedate"])
     self.assertTrue(isinstance(newcase.stringattr, dict))
     self.assertEqual("neither should this", newcase.stringattr["#text"])
     self.assertEqual("i am a string", newcase.stringattr["@somestring"])
     restore_payload = generate_restore_payload(self.project, dummy_user())
     # ghetto
     self.assertTrue('<dateattr somedate="2012-01-01">' in restore_payload)
     self.assertTrue('<stringattr somestring="i am a string">' in restore_payload)
Ejemplo n.º 10
0
 def testRestoreAttributes(self):
     file_path = os.path.join(os.path.dirname(__file__),
                              "data", "attributes.xml")
     with open(file_path, "rb") as f:
         xml_data = f.read()
     form = post_xform_to_couch(xml_data)
     process_cases(form)
     
     [newcase] = CommCareCase.view("case/by_user", reduce=False, include_docs=True).all()
     self.assertTrue(isinstance(newcase.adate, dict))
     self.assertEqual(date(2012,02,01), newcase.adate["#text"])
     self.assertEqual("i am an attribute", newcase.adate["@someattr"])
     self.assertTrue(isinstance(newcase.dateattr, dict))
     self.assertEqual("this shouldn't break", newcase.dateattr["#text"])
     self.assertEqual(date(2012,01,01), newcase.dateattr["@somedate"])
     self.assertTrue(isinstance(newcase.stringattr, dict))
     self.assertEqual("neither should this", newcase.stringattr["#text"])
     self.assertEqual("i am a string", newcase.stringattr["@somestring"])
     restore_payload = generate_restore_payload(dummy_user())
     # ghetto
     self.assertTrue('<dateattr somedate="2012-01-01">' in restore_payload)
     self.assertTrue('<stringattr somestring="i am a string">' in restore_payload)
Ejemplo n.º 11
0
    def testUserRestoreWithCase(self):
        file_path = os.path.join(os.path.dirname(__file__), "data", "create_short.xml")
        with open(file_path, "rb") as f:
            xml_data = f.read()
        form = post_xform_to_couch(xml_data, domain=self.domain)
        process_cases(form)

        expected_case_block = """
        <case case_id="asdf" date_modified="2010-06-29T13:42:50.000000Z" user_id="foo"
            xmlns="http://commcarehq.org/case/transaction/v2">
            <create>
                <case_type>test_case_type</case_type>
                <case_name>test case name</case_name>
                <owner_id>foo</owner_id>
            </create>
            <update>
                <external_id>someexternal</external_id>
            </update>
        </case>"""

        restore_payload = generate_restore_payload(
            project=Domain(name=self.domain),
            user=dummy_user(),
            items=True,
            version=V3
        )
        sync_log_id = SyncLog.view(
            "phone/sync_logs_by_user",
            include_docs=True,
            reduce=False,
        ).one().get_id
        check_xml_line_by_line(
            self,
            dummy_restore_xml(sync_log_id, expected_case_block, items=4),
            restore_payload
        )
Ejemplo n.º 12
0
 def tearDown(self):
     delete_all_cases()
     delete_all_sync_logs()
     restore_config = RestoreConfig(project=self.project, user=dummy_user())
     restore_config.cache.delete(restore_config._initial_cache_key())
Ejemplo n.º 13
0
 def testRegistrationXML(self):
     check_xml_line_by_line(self, dummy_user_xml(),
                            xml.get_registration_xml(dummy_user()))
Ejemplo n.º 14
0
    def _test_sync_token(self, items):
        """
        Tests sync token / sync mode support
        """
        file_path = os.path.join(os.path.dirname(__file__),
                                 "data", "create_short.xml")
        with open(file_path, "rb") as f:
            xml_data = f.read()
        form = post_xform_to_couch(xml_data, domain=self.project.name)
        process_cases(form)

        time.sleep(1)
        restore_payload = generate_restore_payload(self.project, dummy_user(), items=items)

        sync_log_id = SyncLog.view(
            "phone/sync_logs_by_user",
            include_docs=True,
            reduce=False
        ).one().get_id
        expected_restore_payload = dummy_restore_xml(
            sync_log_id,
            const.CREATE_SHORT,
            items=4 if items else None,
        )
        check_xml_line_by_line(self, expected_restore_payload, restore_payload)

        time.sleep(1)
        sync_restore_payload = generate_restore_payload(
            project=self.project,
            user=dummy_user(),
            restore_id=sync_log_id,
            items=items,
        )
        all_sync_logs = SyncLog.view(
            "phone/sync_logs_by_user",
            include_docs=True,
            reduce=False,
        ).all()
        [latest_log] = [log for log in all_sync_logs
                        if log.get_id != sync_log_id]

        # should no longer have a case block in the restore XML
        check_xml_line_by_line(
            self,
            dummy_restore_xml(latest_log.get_id, items=3 if items else None),
            sync_restore_payload,
        )

        # apply an update
        time.sleep(1)
        file_path = os.path.join(os.path.dirname(__file__),
                                 "data", "update_short.xml")
        with open(file_path, "rb") as f:
            xml_data = f.read()
        form = post_xform_to_couch(xml_data, domain=self.project.name)
        process_cases(form)

        time.sleep(1)
        sync_restore_payload = generate_restore_payload(
            self.project,
            user=dummy_user(),
            restore_id=latest_log.get_id,
            items=items,
        )
        all_sync_logs = SyncLog.view(
            "phone/sync_logs_by_user",
            include_docs=True,
            reduce=False,
        ).all()
        [even_latest_log] = [log for log in all_sync_logs
                             if log.get_id != sync_log_id and
                             log.get_id != latest_log.get_id]

        # case block should come back
        expected_sync_restore_payload = dummy_restore_xml(
            even_latest_log.get_id,
            const.UPDATE_SHORT,
            items=4 if items else None,
        )
        check_xml_line_by_line(self, expected_sync_restore_payload,
                               sync_restore_payload)
Ejemplo n.º 15
0
    def testUserRestoreWithCase(self):
        file_path = os.path.join(os.path.dirname(__file__),
                                 "data", "create_short.xml")
        with open(file_path, "rb") as f:
            xml_data = f.read()
        form = post_xform_to_couch(xml_data, domain=self.project.name)
        # implicit length assertion
        [newcase] = process_cases(form)
        user = dummy_user()

        self.assertEqual(1, len(list(
            BatchedCaseSyncOperation(RestoreState(self.project, user, RestoreParams())).get_all_case_updates()
        )))
        expected_case_block = """
        <case>
            <case_id>asdf</case_id>
            <date_modified>2010-06-29T13:42:50.000000Z</date_modified>
            <create>
                <case_type_id>test_case_type</case_type_id>
                <user_id>foo</user_id>
                <case_name>test case name</case_name>
                <external_id>someexternal</external_id>
            </create>
        </case>"""
        check_xml_line_by_line(self, expected_case_block, xml.get_case_xml(newcase, [case_const.CASE_ACTION_CREATE,
                                                                                     case_const.CASE_ACTION_UPDATE]))

        # check v2
        expected_v2_case_block = """
        <case case_id="asdf" date_modified="2010-06-29T13:42:50.000000Z" user_id="foo" xmlns="http://commcarehq.org/case/transaction/v2" >
            <create>
                <case_type>test_case_type</case_type>
                <case_name>test case name</case_name>
                <owner_id>foo</owner_id>
            </create>
            <update>
                <external_id>someexternal</external_id>
            </update>
        </case>"""
        check_xml_line_by_line(
            self,
            expected_v2_case_block,
            xml.get_case_xml(
                newcase,
                [case_const.CASE_ACTION_CREATE, case_const.CASE_ACTION_UPDATE],
                version="2.0",
            ),
        )

        restore_payload = generate_restore_payload(
            project=self.project,
            user=dummy_user(),
            items=True,
        )
        sync_log_id = SyncLog.view(
            "phone/sync_logs_by_user",
            include_docs=True,
            reduce=False,
        ).one().get_id
        check_xml_line_by_line(
            self,
            dummy_restore_xml(sync_log_id, expected_case_block, items=4),
            restore_payload
        )
Ejemplo n.º 16
0
 def testUserRestore(self):
     self.assertEqual(0, len(SyncLog.view("phone/sync_logs_by_user", include_docs=True, reduce=False).all()))
     restore_payload = generate_restore_payload(dummy_user())
     # implicit length assertion
     [sync_log] = SyncLog.view("phone/sync_logs_by_user", include_docs=True, reduce=False).all()
     check_xml_line_by_line(self, dummy_restore_xml(sync_log.get_id), restore_payload)