def test_archiving_only_form(self):
"""
Checks that archiving the only form associated with the case archives
the case and unarchiving unarchives it.
"""
case_id = _post_util(create=True, p1='p1-1', p2='p2-1')
case_accessors = CaseAccessors(REBUILD_TEST_DOMAIN)
case = case_accessors.get_case(case_id)
self.assertFalse(case.is_deleted)
if should_use_sql_backend(REBUILD_TEST_DOMAIN):
self.assertEqual(1, len(case.actions))
else:
self.assertEqual(2, len(case.actions))
[form_id] = case.xform_ids
form = FormAccessors(REBUILD_TEST_DOMAIN).get_form(form_id)
form.archive()
case = case_accessors.get_case(case_id)
self.assertTrue(case.is_deleted)
# should just have the 'rebuild' action
self.assertEqual(1, len(case.actions))
self.assertTrue(case.actions[0].is_case_rebuild)
form.unarchive()
case = case_accessors.get_case(case_id)
self.assertFalse(case.is_deleted)
self.assertEqual(3, len(case.actions))
self.assertTrue(case.actions[-1].is_case_rebuild)
def test_archiving_only_form(self):
"""
Checks that archiving the only form associated with the case archives
the case and unarchiving unarchives it.
"""
case_id = _post_util(create=True, p1='p1-1', p2='p2-1')
case_accessors = CaseAccessors(REBUILD_TEST_DOMAIN)
case = case_accessors.get_case(case_id)
self.assertFalse(case.is_deleted)
if should_use_sql_backend(REBUILD_TEST_DOMAIN):
self.assertEqual(1, len(case.actions))
else:
self.assertEqual(2, len(case.actions))
[form_id] = case.xform_ids
form = FormAccessors(REBUILD_TEST_DOMAIN).get_form(form_id)
form.archive()
case = case_accessors.get_case(case_id)
self.assertTrue(case.is_deleted)
# should just have the 'rebuild' action
self.assertEqual(1, len(case.actions))
self.assertTrue(case.actions[0].is_case_rebuild)
form.unarchive()
case = case_accessors.get_case(case_id)
self.assertFalse(case.is_deleted)
self.assertEqual(3, len(case.actions))
self.assertTrue(case.actions[-1].is_case_rebuild)
def test_archie_modified_on(self):
case_id = uuid.uuid4().hex
now = datetime.utcnow().replace(microsecond=0)
earlier = now - timedelta(hours=1)
way_earlier = now - timedelta(days=1)
# make sure we timestamp everything so they have the right order
create_block = CaseBlock(case_id,
create=True,
date_modified=way_earlier)
post_case_blocks([create_block.as_xml()],
form_extras={'received_on': way_earlier})
update_block = CaseBlock(case_id,
update={'foo': 'bar'},
date_modified=earlier)
post_case_blocks([update_block.as_xml()],
form_extras={'received_on': earlier})
case_accessors = CaseAccessors(REBUILD_TEST_DOMAIN)
case = case_accessors.get_case(case_id)
self.assertEqual(earlier, case.modified_on)
second_form = FormAccessors(REBUILD_TEST_DOMAIN).get_form(
case.xform_ids[-1])
second_form.archive()
case = case_accessors.get_case(case_id)
self.assertEqual(way_earlier, case.modified_on)
def test_archive_only_form(self):
# check no data in stock states
ledger_accessors = LedgerAccessors(self.domain.name)
ledger_values = ledger_accessors.get_ledger_values_for_case(
self.sp.case_id)
self.assertEqual(0, len(ledger_values))
initial_amounts = [(p._id, float(100)) for p in self.products]
form_id = self.submit_xml_form(balance_submission(initial_amounts))
# check that we made stuff
def _assert_initial_state():
if should_use_sql_backend(self.domain):
self.assertEqual(
3,
LedgerTransaction.objects.filter(form_id=form_id).count())
else:
self.assertEqual(
1,
StockReport.objects.filter(form_id=form_id).count())
self.assertEqual(
3,
StockTransaction.objects.filter(
report__form_id=form_id).count())
ledger_values = ledger_accessors.get_ledger_values_for_case(
self.sp.case_id)
self.assertEqual(3, len(ledger_values))
for state in ledger_values:
self.assertEqual(100, int(state.stock_on_hand))
_assert_initial_state()
# archive and confirm commtrack data is cleared
form = FormAccessors(self.domain.name).get_form(form_id)
form.archive()
self.assertEqual(
0,
len(ledger_accessors.get_ledger_values_for_case(self.sp.case_id)))
if should_use_sql_backend(self.domain):
self.assertEqual(
0,
LedgerTransaction.objects.filter(form_id=form_id).count())
else:
self.assertEqual(
0,
StockReport.objects.filter(form_id=form_id).count())
self.assertEqual(
0,
StockTransaction.objects.filter(
report__form_id=form_id).count())
# unarchive and confirm commtrack data is restored
form.unarchive()
_assert_initial_state()
def test_archive_last_form(self):
initial_amounts = [(p._id, float(100)) for p in self.products]
self.submit_xml_form(
balance_submission(initial_amounts),
timestamp=datetime.utcnow() + timedelta(-30)
)
final_amounts = [(p._id, float(50)) for i, p in enumerate(self.products)]
second_form_id = self.submit_xml_form(balance_submission(final_amounts))
ledger_accessors = LedgerAccessors(self.domain.name)
def _assert_initial_state():
if should_use_sql_backend(self.domain):
self.assertEqual(3, len(self._get_all_ledger_transactions(Q(form_id=second_form_id))))
else:
self.assertEqual(1, StockReport.objects.filter(form_id=second_form_id).count())
# 6 = 3 stockonhand and 3 inferred consumption txns
self.assertEqual(6, StockTransaction.objects.filter(report__form_id=second_form_id).count())
ledger_values = ledger_accessors.get_ledger_values_for_case(self.sp.case_id)
self.assertEqual(3, len(ledger_values))
for lv in ledger_values:
self.assertEqual(50, lv.stock_on_hand)
self.assertEqual(
round(float(lv.daily_consumption), 2),
1.67
)
# check initial setup
_assert_initial_state()
# archive and confirm commtrack data is deleted
form = FormAccessors(self.domain.name).get_form(second_form_id)
with process_pillow_changes('LedgerToElasticsearchPillow'):
form.archive()
if should_use_sql_backend(self.domain):
self.assertEqual(0, len(self._get_all_ledger_transactions(Q(form_id=second_form_id))))
else:
self.assertEqual(0, StockReport.objects.filter(form_id=second_form_id).count())
self.assertEqual(0, StockTransaction.objects.filter(report__form_id=second_form_id).count())
ledger_values = ledger_accessors.get_ledger_values_for_case(self.sp.case_id)
self.assertEqual(3, len(ledger_values))
for state in ledger_values:
# balance should be reverted to 100 in the StockState
self.assertEqual(100, int(state.stock_on_hand))
# consumption should be none since there will only be 1 data point
self.assertIsNone(state.daily_consumption)
# unarchive and confirm commtrack data is restored
with process_pillow_changes('LedgerToElasticsearchPillow'):
form.unarchive()
_assert_initial_state()
def test_archive_last_form(self):
initial_amounts = [(p._id, float(100)) for p in self.products]
self.submit_xml_form(
balance_submission(initial_amounts),
timestamp=datetime.utcnow() + timedelta(-30)
)
final_amounts = [(p._id, float(50)) for i, p in enumerate(self.products)]
second_form_id = self.submit_xml_form(balance_submission(final_amounts))
ledger_accessors = LedgerAccessors(self.domain.name)
def _assert_initial_state():
if should_use_sql_backend(self.domain):
self.assertEqual(3, len(self._get_all_ledger_transactions(Q(form_id=second_form_id))))
else:
self.assertEqual(1, StockReport.objects.filter(form_id=second_form_id).count())
# 6 = 3 stockonhand and 3 inferred consumption txns
self.assertEqual(6, StockTransaction.objects.filter(report__form_id=second_form_id).count())
ledger_values = ledger_accessors.get_ledger_values_for_case(self.sp.case_id)
self.assertEqual(3, len(ledger_values))
for lv in ledger_values:
self.assertEqual(50, lv.stock_on_hand)
self.assertEqual(
round(float(lv.daily_consumption), 2),
1.67
)
# check initial setup
_assert_initial_state()
# archive and confirm commtrack data is deleted
form = FormAccessors(self.domain.name).get_form(second_form_id)
with process_pillow_changes('LedgerToElasticsearchPillow'):
form.archive()
if should_use_sql_backend(self.domain):
self.assertEqual(0, len(self._get_all_ledger_transactions(Q(form_id=second_form_id))))
else:
self.assertEqual(0, StockReport.objects.filter(form_id=second_form_id).count())
self.assertEqual(0, StockTransaction.objects.filter(report__form_id=second_form_id).count())
ledger_values = ledger_accessors.get_ledger_values_for_case(self.sp.case_id)
self.assertEqual(3, len(ledger_values))
for state in ledger_values:
# balance should be reverted to 100 in the StockState
self.assertEqual(100, int(state.stock_on_hand))
# consumption should be none since there will only be 1 data point
self.assertIsNone(state.daily_consumption)
# unarchive and confirm commtrack data is restored
with process_pillow_changes('LedgerToElasticsearchPillow'):
form.unarchive()
_assert_initial_state()
def test_archived_form_gets_removed_from_case_xform_ids(self):
initial_amounts = [(p._id, float(100)) for p in self.products]
instance_id = self.submit_xml_form(balance_submission(initial_amounts),
timestamp=datetime.utcnow() +
timedelta(-30))
case_accessors = CaseAccessors(self.domain.name)
case = case_accessors.get_case(self.sp.case_id)
self.assertIn(instance_id, case.xform_ids)
form = FormAccessors(self.domain.name).get_form(instance_id)
form.archive()
case = case_accessors.get_case(self.sp.case_id)
self.assertNotIn(instance_id, case.xform_ids)
def test_archived_form_gets_removed_from_case_xform_ids(self):
initial_amounts = [(p._id, float(100)) for p in self.products]
instance_id = self.submit_xml_form(
balance_submission(initial_amounts),
timestamp=datetime.utcnow() + timedelta(-30)
)
case_accessors = CaseAccessors(self.domain.name)
case = case_accessors.get_case(self.sp.case_id)
self.assertIn(instance_id, case.xform_ids)
form = FormAccessors(self.domain.name).get_form(instance_id)
form.archive()
case = case_accessors.get_case(self.sp.case_id)
self.assertNotIn(instance_id, case.xform_ids)
def test_archive_against_deleted_case(self):
now = datetime.utcnow()
# make sure we timestamp everything so they have the right order
case_id = _post_util(create=True, p1='p1', form_extras={'received_on': now})
_post_util(case_id=case_id, p2='p2',
form_extras={'received_on': now + timedelta(seconds=1)})
_post_util(case_id=case_id, p3='p3',
form_extras={'received_on': now + timedelta(seconds=2)})
case_accessors = CaseAccessors(REBUILD_TEST_DOMAIN)
case = case_accessors.get_case(case_id)
case_accessors.soft_delete_cases([case_id])
[f1, f2, f3] = case.xform_ids
f2_doc = FormAccessors(REBUILD_TEST_DOMAIN).get_form(f2)
f2_doc.archive()
case = case_accessors.get_case(case_id)
self.assertTrue(case.is_deleted)
def test_archive_against_deleted_case(self):
now = datetime.utcnow()
# make sure we timestamp everything so they have the right order
case_id = _post_util(create=True, p1='p1', form_extras={'received_on': now})
_post_util(case_id=case_id, p2='p2',
form_extras={'received_on': now + timedelta(seconds=1)})
_post_util(case_id=case_id, p3='p3',
form_extras={'received_on': now + timedelta(seconds=2)})
case_accessors = CaseAccessors(REBUILD_TEST_DOMAIN)
case = case_accessors.get_case(case_id)
case_accessors.soft_delete_cases([case_id])
[f1, f2, f3] = case.xform_ids
f2_doc = FormAccessors(REBUILD_TEST_DOMAIN).get_form(f2)
f2_doc.archive()
case = case_accessors.get_case(case_id)
self.assertTrue(case.is_deleted)
def reprocess_archive_stubs():
# Check for archive stubs
from corehq.form_processor.interfaces.dbaccessors import FormAccessors
from couchforms.models import UnfinishedArchiveStub
stubs = UnfinishedArchiveStub.objects.filter()
datadog_gauge('commcare.unfinished_archive_stubs', len(stubs))
start = time.time()
cutoff = start + timedelta(minutes=4).total_seconds()
for stub in stubs:
# Exit this task after 4 minutes so that the same stub isn't ever processed in multiple queues.
if time.time() - start > cutoff:
return
xform = FormAccessors(stub.domain).get_form(form_id=stub.xform_id)
# If the history wasn't updated the first time around, run the whole thing again.
if not stub.history_updated:
if stub.archive:
xform.archive(user_id=stub.user_id)
else:
xform.unarchive(user_id=stub.user_id)
# If the history was updated the first time around, just send the update to kafka
else:
xform.publish_archive_action_to_kafka(user_id=stub.user_id, archive=stub.archive)
def reprocess_archive_stubs():
# Check for archive stubs
from corehq.form_processor.interfaces.dbaccessors import FormAccessors
from couchforms.models import UnfinishedArchiveStub
stubs = UnfinishedArchiveStub.objects.filter()
datadog_gauge('commcare.unfinished_archive_stubs', len(stubs))
start = time.time()
cutoff = start + timedelta(minutes=4).total_seconds()
for stub in stubs:
# Exit this task after 4 minutes so that the same stub isn't ever processed in multiple queues.
if time.time() - start > cutoff:
return
xform = FormAccessors(stub.domain).get_form(form_id=stub.xform_id)
# If the history wasn't updated the first time around, run the whole thing again.
if not stub.history_updated:
if stub.archive:
xform.archive(user_id=stub.user_id)
else:
xform.unarchive(user_id=stub.user_id)
# If the history was updated the first time around, just send the update to kafka
else:
xform.publish_archive_action_to_kafka(user_id=stub.user_id, archive=stub.archive)
def test_archie_modified_on(self):
case_id = uuid.uuid4().hex
now = datetime.utcnow().replace(microsecond=0)
earlier = now - timedelta(hours=1)
way_earlier = now - timedelta(days=1)
# make sure we timestamp everything so they have the right order
create_block = CaseBlock(case_id, create=True, date_modified=way_earlier)
post_case_blocks(
[create_block.as_xml()], form_extras={'received_on': way_earlier}
)
update_block = CaseBlock(case_id, update={'foo': 'bar'}, date_modified=earlier)
post_case_blocks(
[update_block.as_xml()], form_extras={'received_on': earlier}
)
case_accessors = CaseAccessors(REBUILD_TEST_DOMAIN)
case = case_accessors.get_case(case_id)
self.assertEqual(earlier, case.modified_on)
second_form = FormAccessors(REBUILD_TEST_DOMAIN).get_form(case.xform_ids[-1])
second_form.archive()
case = case_accessors.get_case(case_id)
self.assertEqual(way_earlier, case.modified_on)
def test_archive_only_form(self):
# check no data in stock states
ledger_accessors = LedgerAccessors(self.domain.name)
ledger_values = ledger_accessors.get_ledger_values_for_case(self.sp.case_id)
self.assertEqual(0, len(ledger_values))
initial_amounts = [(p._id, float(100)) for p in self.products]
form_id = self.submit_xml_form(balance_submission(initial_amounts))
# check that we made stuff
def _assert_initial_state():
if should_use_sql_backend(self.domain.name):
self.assertEqual(3, LedgerTransaction.objects.filter(form_id=form_id).count())
else:
self.assertEqual(1, StockReport.objects.filter(form_id=form_id).count())
self.assertEqual(3, StockTransaction.objects.filter(report__form_id=form_id).count())
ledger_values = ledger_accessors.get_ledger_values_for_case(self.sp.case_id)
self.assertEqual(3, len(ledger_values))
for state in ledger_values:
self.assertEqual(100, int(state.stock_on_hand))
_assert_initial_state()
# archive and confirm commtrack data is cleared
form = FormAccessors(self.domain.name).get_form(form_id)
form.archive()
self.assertEqual(0, len(ledger_accessors.get_ledger_values_for_case(self.sp.case_id)))
if should_use_sql_backend(self.domain.name):
self.assertEqual(0, LedgerTransaction.objects.filter(form_id=form_id).count())
else:
self.assertEqual(0, StockReport.objects.filter(form_id=form_id).count())
self.assertEqual(0, StockTransaction.objects.filter(report__form_id=form_id).count())
# unarchive and confirm commtrack data is restored
form.unarchive()
_assert_initial_state()
