def test_selective_product_sync(self):
user = self.user
expected_xml = self.generate_product_fixture_xml(user)
product_list = Product.by_domain(user.domain)
self._initialize_product_names(len(product_list))
fixture_original = call_fixture_generator(product_fixture_generator, user)[1]
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertXmlEqual(
expected_xml,
ElementTree.tostring(fixture_original)
)
first_sync = sorted(SyncLog.view(
"phone/sync_logs_by_user",
include_docs=True,
reduce=False
).all(), key=lambda x: x.date)[-1]
# make sure the time stamp on this first sync is
# not on the same second that the products were created
first_sync.date += datetime.timedelta(seconds=1)
# second sync is before any changes are made, so there should
# be no products synced
fixture_pre_change = call_fixture_generator(product_fixture_generator, user, last_sync=first_sync)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertEqual(
[],
fixture_pre_change,
"Fixture was not empty on second sync"
)
second_sync = sorted(SyncLog.view(
"phone/sync_logs_by_user",
include_docs=True,
reduce=False
).all(), key=lambda x: x.date)[-1]
self.assertTrue(first_sync._id != second_sync._id)
# save should make the product more recently updated than the
# last sync
for product in product_list:
product.save()
# now that we've updated a product, we should get
# product data in sync again
fixture_post_change = call_fixture_generator(product_fixture_generator, user, last_sync=second_sync)[1]
# regenerate the fixture xml to make sure it is still legit
self.assertXmlEqual(
expected_xml,
ElementTree.tostring(fixture_post_change)
)
def test_selective_program_sync(self):
user = self.user
Program(
domain=user.domain,
name="test1",
code="t1"
).save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture_original = call_fixture_generator(program_fixture_generator, user)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture_original[0])
)
first_sync = self._get_latest_synclog()
# make sure the time stamp on this first sync is
# not on the same second that the programs were created
first_sync.date += datetime.timedelta(seconds=1)
# second sync is before any changes are made, so there should
# be no programs synced
fixture_pre_change = call_fixture_generator(program_fixture_generator, user, last_sync=first_sync)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertEqual(
[],
fixture_pre_change,
"Fixture was not empty on second sync"
)
second_sync = self._get_latest_synclog()
self.assertTrue(first_sync._id != second_sync._id)
# save should make the program more recently updated than the
# last sync
for program in program_list:
program.save()
# now that we've updated a program, we should get
# program data in sync again
fixture_post_change = call_fixture_generator(program_fixture_generator, user, last_sync=second_sync)
# regenerate the fixture xml to make sure it is still legit
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture_post_change[0])
)
def test_selective_program_sync(self):
user = self.user
Program(
domain=user.domain,
name="test1",
code="t1"
).save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture_original = call_fixture_generator(program_fixture_generator, user)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture_original[0])
)
first_sync = self._get_latest_synclog()
# make sure the time stamp on this first sync is
# not on the same second that the programs were created
first_sync.date += datetime.timedelta(seconds=1)
# second sync is before any changes are made, so there should
# be no programs synced
fixture_pre_change = call_fixture_generator(program_fixture_generator, user, last_sync=first_sync)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertEqual(
[],
fixture_pre_change,
"Fixture was not empty on second sync"
)
second_sync = self._get_latest_synclog()
self.assertTrue(first_sync._id != second_sync._id)
# save should make the program more recently updated than the
# last sync
for program in program_list:
program.save()
# now that we've updated a program, we should get
# program data in sync again
fixture_post_change = call_fixture_generator(program_fixture_generator, user, last_sync=second_sync)
# regenerate the fixture xml to make sure it is still legit
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture_post_change[0])
)
def test_selective_product_sync(self):
user = self.user
expected_xml = self.generate_product_fixture_xml(user)
product_list = Product.by_domain(user.domain)
self._initialize_product_names(len(product_list))
fixture_original = call_fixture_generator(product_fixture_generator, user)[1]
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertXmlEqual(
expected_xml,
ElementTree.tostring(fixture_original)
)
first_sync = self._get_latest_synclog()
# make sure the time stamp on this first sync is
# not on the same second that the products were created
first_sync.date += datetime.timedelta(seconds=1)
# second sync is before any changes are made, so there should
# be no products synced
fixture_pre_change = call_fixture_generator(product_fixture_generator, user, last_sync=first_sync)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertEqual(
[],
fixture_pre_change,
"Fixture was not empty on second sync"
)
second_sync = self._get_latest_synclog()
self.assertTrue(first_sync._id != second_sync._id)
# save should make the product more recently updated than the
# last sync
for product in product_list:
product.save()
# now that we've updated a product, we should get
# product data in sync again
fixture_post_change = call_fixture_generator(product_fixture_generator, user, last_sync=second_sync)[1]
# regenerate the fixture xml to make sure it is still legit
self.assertXmlEqual(
expected_xml,
ElementTree.tostring(fixture_post_change)
)
def testRestoreAttributes(self):
xml_data = self.get_xml('attributes').decode('utf-8')
xml_data = xml_data.format(user_id=self.restore_user.user_id)
newcase = submit_form_locally(xml_data, domain=self.project.name).case
self.assertTrue(isinstance(newcase.case_json['adate'], dict))
self.assertEqual('2012-02-01', newcase.case_json['adate']["#text"])
self.assertEqual("i am an attribute",
newcase.case_json['adate']["@someattr"])
self.assertTrue(isinstance(newcase.case_json['dateattr'], dict))
self.assertEqual("this shouldn't break",
newcase.case_json['dateattr']["#text"])
self.assertEqual('2012-01-01',
newcase.case_json['dateattr']["@somedate"])
self.assertTrue(isinstance(newcase.case_json['stringattr'], dict))
self.assertEqual("neither should this",
newcase.case_json['stringattr']["#text"])
self.assertEqual("i am a string",
newcase.case_json['stringattr']["@somestring"])
restore_payload = deprecated_generate_restore_payload(
self.project, self.restore_user).decode('utf-8')
# ghetto
self.assertIn('<dateattr somedate="2012-01-01">', restore_payload)
self.assertIn('<stringattr somestring="i am a string">',
restore_payload)
def test_user_restore(self):
self.assertEqual(0, self._get_synclog_count())
restore_payload = deprecated_generate_restore_payload(
self.project, self.restore_user, items=True)
sync_log = self._get_the_first_synclog()
check_xml_line_by_line(
self,
dummy_restore_xml(sync_log.get_id, items=3, user=self.restore_user),
restore_payload,
)
def test_user_restore(self):
self.assertEqual(0, self._get_synclog_count())
restore_payload = deprecated_generate_restore_payload(
self.project, self.restore_user, items=True)
sync_log = self._get_the_first_synclog()
check_xml_line_by_line(
self,
dummy_restore_xml(sync_log.get_id, items=3, user=self.restore_user),
restore_payload,
)
def test_user_restore(self):
self.assertEqual(0, SyncLog.view(
"phone/sync_logs_by_user",
include_docs=True,
reduce=False,
).count())
restore_payload = deprecated_generate_restore_payload(
self.project, self.restore_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, user=self.restore_user),
restore_payload,
)
def testRestoreAttributes(self):
xml_data = self.get_xml('attributes')
xml_data = xml_data.format(user_id=self.restore_user.user_id)
newcase = submit_form_locally(xml_data, domain=self.project.name).case
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 = deprecated_generate_restore_payload(
self.project, self.restore_user)
# ghetto
self.assertTrue('<dateattr somedate="2012-01-01">' in restore_payload)
self.assertTrue('<stringattr somestring="i am a string">' in restore_payload)
def testRestoreAttributes(self):
xml_data = self.get_xml('attributes').decode('utf-8')
xml_data = xml_data.format(user_id=self.restore_user.user_id)
newcase = submit_form_locally(xml_data, domain=self.project.name).case
self.assertTrue(isinstance(newcase.adate, dict))
self.assertEqual(date(2012, 2, 1), 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, 1, 1), 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 = deprecated_generate_restore_payload(
self.project, self.restore_user).decode('utf-8')
# ghetto
self.assertTrue('<dateattr somedate="2012-01-01">' in restore_payload)
self.assertTrue('<stringattr somestring="i am a string">' in restore_payload)
def _test_sync_token(self, items):
"""
Tests sync token / sync mode support
"""
xml_data = self.get_xml('create_short')
xml_data = xml_data.format(user_id=self.restore_user.user_id)
submit_form_locally(xml_data, domain=self.project.name)
restore_payload = deprecated_generate_restore_payload(
self.project, self.restore_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.format(user_id=self.restore_user.user_id),
items=4 if items else None,
user=self.restore_user,
)
check_xml_line_by_line(self, expected_restore_payload, restore_payload)
sync_restore_payload = deprecated_generate_restore_payload(
project=self.project,
user=self.restore_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,
user=self.restore_user,
),
sync_restore_payload,
)
# apply an update
xml_data = self.get_xml('update_short')
xml_data = xml_data.format(user_id=self.restore_user.user_id)
submit_form_locally(xml_data, domain=self.project.name)
sync_restore_payload = deprecated_generate_restore_payload(
self.project,
user=self.restore_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.format(user_id=self.restore_user.user_id),
items=4 if items else None,
user=self.restore_user
)
check_xml_line_by_line(self, expected_sync_restore_payload,
sync_restore_payload)
<date_opened>2010-06-29</date_opened>
</update>
</case>""".format(user_id=self.restore_user.user_id)
check_xml_line_by_line(
self,
expected_v2_case_block,
xml.get_case_xml(
result.case,
[case_const.CASE_ACTION_CREATE, case_const.CASE_ACTION_UPDATE],
version="2.0",
),
)
restore_payload = deprecated_generate_restore_payload(
project=self.project,
user=self.restore_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, user=self.restore_user),
restore_payload
)
def testSyncTokenWithItems(self):
self._test_sync_token(items=True)
def _test_sync_token(self, items):
"""
Tests sync token / sync mode support
"""
def get_all_syncslogs():
return [
properly_wrap_sync_log(log.doc)
for log in SyncLogSQL.objects.all()
]
xml_data = self.get_xml('create_short').decode('utf-8')
xml_data = xml_data.format(user_id=self.restore_user.user_id)
submit_form_locally(xml_data, domain=self.project.name)
restore_payload = deprecated_generate_restore_payload(
self.project, self.restore_user, items=items)
sync_log_id = SyncLogSQL.objects.filter(
user_id=self.restore_user.user_id).order_by(
'date').last().synclog_id.hex
expected_restore_payload = dummy_restore_xml(
sync_log_id,
const.CREATE_SHORT.format(user_id=self.restore_user.user_id),
items=4 if items else None,
user=self.restore_user,
)
check_xml_line_by_line(self, expected_restore_payload, restore_payload)
sync_restore_payload = deprecated_generate_restore_payload(
project=self.project,
user=self.restore_user,
restore_id=sync_log_id,
items=items,
)
all_sync_logs = get_all_syncslogs()
[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,
user=self.restore_user,
),
sync_restore_payload,
)
# apply an update
xml_data = self.get_xml('update_short').decode('utf-8')
xml_data = xml_data.format(user_id=self.restore_user.user_id)
submit_form_locally(xml_data, domain=self.project.name)
sync_restore_payload = deprecated_generate_restore_payload(
self.project,
user=self.restore_user,
restore_id=latest_log.get_id,
items=items,
)
all_sync_logs = get_all_syncslogs()
[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.format(user_id=self.restore_user.user_id),
items=4 if items else None,
user=self.restore_user)
check_xml_line_by_line(self, expected_sync_restore_payload,
sync_restore_payload)
def _test_sync_token(self, items):
"""
Tests sync token / sync mode support
"""
def get_all_syncslogs():
return [properly_wrap_sync_log(log.doc) for log in SyncLogSQL.objects.all()]
xml_data = self.get_xml('create_short').decode('utf-8')
xml_data = xml_data.format(user_id=self.restore_user.user_id)
submit_form_locally(xml_data, domain=self.project.name)
restore_payload = deprecated_generate_restore_payload(
self.project, self.restore_user, items=items)
sync_log_id = get_last_synclog_for_user(self.restore_user.user_id).get_id
expected_restore_payload = dummy_restore_xml(
sync_log_id,
const.CREATE_SHORT.format(user_id=self.restore_user.user_id),
items=4 if items else None,
user=self.restore_user,
)
check_xml_line_by_line(self, expected_restore_payload, restore_payload)
sync_restore_payload = deprecated_generate_restore_payload(
project=self.project,
user=self.restore_user,
restore_id=sync_log_id,
items=items,
)
all_sync_logs = get_all_syncslogs()
[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,
user=self.restore_user,
),
sync_restore_payload,
)
# apply an update
xml_data = self.get_xml('update_short').decode('utf-8')
xml_data = xml_data.format(user_id=self.restore_user.user_id)
submit_form_locally(xml_data, domain=self.project.name)
sync_restore_payload = deprecated_generate_restore_payload(
self.project,
user=self.restore_user,
restore_id=latest_log.get_id,
items=items,
)
all_sync_logs = get_all_syncslogs()
[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.format(user_id=self.restore_user.user_id),
items=4 if items else None,
user=self.restore_user
)
check_xml_line_by_line(self, expected_sync_restore_payload,
sync_restore_payload)
def testUserRestoreWithCase(self):
xml_data = self.get_xml('create_short').decode('utf-8')
xml_data = xml_data.format(user_id=self.restore_user.user_id)
# implicit length assertion
result = 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>{user_id}</user_id>
<case_name>test case name</case_name>
<external_id>someexternal</external_id>
</create>
<update>
<date_opened>2010-06-29</date_opened>
</update>
</case>""".format(user_id=self.restore_user.user_id)
check_xml_line_by_line(
self,
expected_case_block,
xml.get_case_xml(
result.case,
[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="{user_id}" xmlns="http://commcarehq.org/case/transaction/v2" >
<create>
<case_type>test_case_type</case_type>
<case_name>test case name</case_name>
<owner_id>{user_id}</owner_id>
</create>
<update>
<external_id>someexternal</external_id>
<date_opened>2010-06-29</date_opened>
</update>
</case>""".format(user_id=self.restore_user.user_id)
check_xml_line_by_line(
self,
expected_v2_case_block,
xml.get_case_xml(
result.case,
[case_const.CASE_ACTION_CREATE, case_const.CASE_ACTION_UPDATE],
version="2.0",
),
)
restore_payload = deprecated_generate_restore_payload(
project=self.project,
user=self.restore_user,
items=True,
)
sync_log_id = self._get_the_first_synclog().get_id
check_xml_line_by_line(
self,
dummy_restore_xml(sync_log_id, expected_case_block, items=4, user=self.restore_user),
restore_payload
)