def test_save_form_deprecated(self):
existing_form, new_form = _simulate_form_edit()
FormAccessorSQL.save_deprecated_form(existing_form)
FormAccessorSQL.save_new_form(new_form)
self._validate_deprecation(existing_form, new_form)
def save_processed_models(cls, processed_forms, cases=None, stock_result=None, publish_to_kafka=True):
db_names = {processed_forms.submitted.db}
if processed_forms.deprecated:
db_names |= {processed_forms.deprecated.db}
if cases:
db_names |= {case.db for case in cases}
if stock_result:
db_names |= {
ledger_value.db for ledger_value in stock_result.models_to_save
}
with ExitStack() as stack:
for db_name in db_names:
stack.enter_context(transaction.atomic(db_name))
# Save deprecated form first to avoid ID conflicts
if processed_forms.deprecated:
FormAccessorSQL.update_form(processed_forms.deprecated, publish_changes=False)
FormAccessorSQL.save_new_form(processed_forms.submitted)
if cases:
for case in cases:
CaseAccessorSQL.save_case(case)
if stock_result:
ledgers_to_save = stock_result.models_to_save
LedgerAccessorSQL.save_ledger_values(ledgers_to_save, stock_result)
if publish_to_kafka:
cls._publish_changes(processed_forms, cases, stock_result)
def test_save_form_deprecated(self):
existing_form, new_form = _simulate_form_edit()
FormAccessorSQL.save_deprecated_form(existing_form)
FormAccessorSQL.save_new_form(new_form)
self._validate_deprecation(existing_form, new_form)
def test_save_form_deprecated(self):
existing_form, new_form = _simulate_form_edit()
FormAccessorSQL.update_form(existing_form, publish_changes=False)
FormAccessorSQL.save_new_form(new_form)
self._validate_deprecation(existing_form, new_form)
def test_save_new_form(self):
unsaved_form = create_form_for_test(DOMAIN, save=False)
FormAccessorSQL.save_new_form(unsaved_form)
self.assertTrue(unsaved_form.is_saved())
attachments = FormAccessorSQL.get_attachments(unsaved_form.form_id)
self.assertEqual(1, len(attachments))
def test_save_form_deprecated(self):
existing_form, new_form = _simulate_form_edit()
FormAccessorSQL.update_form(existing_form, publish_changes=False)
FormAccessorSQL.save_new_form(new_form)
self._validate_deprecation(existing_form, new_form)
def test_save_new_form(self):
unsaved_form = create_form_for_test(DOMAIN, save=False)
FormAccessorSQL.save_new_form(unsaved_form)
self.assertTrue(unsaved_form.is_saved())
attachments = FormAccessorSQL.get_attachments(unsaved_form.form_id)
self.assertEqual(1, len(attachments))
def _simulate_form_edit():
existing_form = create_form_for_test(DOMAIN, save=False)
FormAccessorSQL.save_new_form(existing_form)
existing_form = FormAccessorSQL.get_form(existing_form.form_id)
new_form = create_form_for_test(DOMAIN, save=False)
new_form.form_id = existing_form.form_id
existing_form, new_form = apply_deprecation(existing_form, new_form)
assert existing_form.form_id != new_form.form_id
return existing_form, new_form
def _simulate_form_edit():
existing_form = create_form_for_test(DOMAIN, save=False)
FormAccessorSQL.save_new_form(existing_form)
existing_form = FormAccessorSQL.get_form(existing_form.form_id)
new_form = create_form_for_test(DOMAIN, save=False)
new_form.form_id = existing_form.form_id
existing_form, new_form = apply_deprecation(existing_form, new_form)
assert existing_form.form_id != new_form.form_id
return existing_form, new_form
def save_processed_models(cls, processed_forms, cases=None, stock_result=None):
db_names = {processed_forms.submitted.db}
if processed_forms.deprecated:
db_names |= {processed_forms.deprecated.db}
if cases:
db_names |= {case.db for case in cases}
if stock_result:
db_names |= {
ledger_value.db for ledger_value in stock_result.models_to_save
}
all_models = filter(None, chain(
processed_forms,
cases or [],
stock_result.models_to_save if stock_result else [],
))
try:
with ExitStack() as stack:
for db_name in db_names:
stack.enter_context(transaction.atomic(db_name))
# Save deprecated form first to avoid ID conflicts
if processed_forms.deprecated:
FormAccessorSQL.update_form(processed_forms.deprecated, publish_changes=False)
FormAccessorSQL.save_new_form(processed_forms.submitted)
if cases:
for case in cases:
CaseAccessorSQL.save_case(case)
if stock_result:
ledgers_to_save = stock_result.models_to_save
LedgerAccessorSQL.save_ledger_values(ledgers_to_save, stock_result)
if cases:
sort_submissions = toggles.SORT_OUT_OF_ORDER_FORM_SUBMISSIONS_SQL.enabled(
processed_forms.submitted.domain, toggles.NAMESPACE_DOMAIN)
if sort_submissions:
for case in cases:
if SqlCaseUpdateStrategy(case).reconcile_transactions_if_necessary():
CaseAccessorSQL.save_case(case)
except DatabaseError:
for model in all_models:
setattr(model, model._meta.pk.attname, None)
for tracked in model.create_models:
setattr(tracked, tracked._meta.pk.attname, None)
raise
try:
cls.publish_changes_to_kafka(processed_forms, cases, stock_result)
except Exception as e:
raise KafkaPublishingError(e)
def save_processed_models(cls, processed_forms, cases=None, stock_updates=None):
with transaction.atomic():
logging.debug('Beginning atomic commit\n')
# Save deprecated form first to avoid ID conflicts
if processed_forms.deprecated:
FormAccessorSQL.save_deprecated_form(processed_forms.deprecated)
FormAccessorSQL.save_new_form(processed_forms.submitted)
if cases:
for case in cases:
CaseAccessorSQL.save_case(case)
for stock_update in stock_updates or []:
stock_update.commit()
cls._publish_changes(processed_forms, cases)
def test_save_form_db_error(self):
form = create_form_for_test(DOMAIN)
dup_form = create_form_for_test(DOMAIN, save=False)
dup_form.form_id = form.form_id
try:
FormAccessorSQL.save_new_form(dup_form)
except Exception:
dup_form.form_id = uuid.uuid4().hex
FormAccessorSQL.save_new_form(dup_form)
else:
self.fail("saving dup form didn't raise an exception")
attachments = FormAccessorSQL.get_attachments(dup_form.form_id)
self.assertEqual(1, len(attachments))
def test_save_form_db_error(self):
form = create_form_for_test(DOMAIN)
dup_form = create_form_for_test(DOMAIN, save=False)
dup_form.form_id = form.form_id
try:
FormAccessorSQL.save_new_form(dup_form)
except Exception:
dup_form.form_id = uuid.uuid4().hex
FormAccessorSQL.save_new_form(dup_form)
else:
self.fail("saving dup form didn't raise an exception")
attachments = FormAccessorSQL.get_attachments(dup_form.form_id)
self.assertEqual(1, len(attachments))
def test_save_form_db_error(self):
form = create_form_for_test(DOMAIN)
dup_form = create_form_for_test(DOMAIN, save=False)
dup_form.form_id = form.form_id
try:
with transaction.atomic(dup_form.db):
# prevent rolled back transaction from rolling back the test's transaction
FormAccessorSQL.save_new_form(dup_form)
except Exception:
dup_form.form_id = uuid.uuid4().hex
FormAccessorSQL.save_new_form(dup_form)
else:
self.fail("saving dup form didn't raise an exception")
attachments = FormAccessorSQL.get_attachments(dup_form.form_id)
self.assertEqual(1, len(attachments))
def save_processed_models(cls, processed_forms, cases=None, stock_result=None):
with transaction.atomic():
logging.debug('Beginning atomic commit\n')
# Save deprecated form first to avoid ID conflicts
if processed_forms.deprecated:
FormAccessorSQL.save_deprecated_form(processed_forms.deprecated)
FormAccessorSQL.save_new_form(processed_forms.submitted)
if cases:
for case in cases:
CaseAccessorSQL.save_case(case)
if stock_result:
ledgers_to_save = stock_result.models_to_save
LedgerAccessorSQL.save_ledger_values(ledgers_to_save, processed_forms.deprecated)
cls._publish_changes(processed_forms, cases, stock_result)
def save_processed_models(cls, processed_forms, cases=None, stock_result=None):
with transaction.atomic():
logging.debug('Beginning atomic commit\n')
# Save deprecated form first to avoid ID conflicts
if processed_forms.deprecated:
FormAccessorSQL.save_deprecated_form(processed_forms.deprecated)
FormAccessorSQL.save_new_form(processed_forms.submitted)
if cases:
for case in cases:
CaseAccessorSQL.save_case(case)
if stock_result:
ledgers_to_save = stock_result.models_to_save
LedgerAccessorSQL.save_ledger_values(ledgers_to_save, processed_forms.deprecated)
cls._publish_changes(processed_forms, cases, stock_result)
def save_processed_models(cls,
processed_forms,
cases=None,
stock_result=None,
publish_to_kafka=True):
db_names = {processed_forms.submitted.db}
if processed_forms.deprecated:
db_names |= {processed_forms.deprecated.db}
if cases:
db_names |= {case.db for case in cases}
if stock_result:
db_names |= {
ledger_value.db
for ledger_value in stock_result.models_to_save
}
with ExitStack() as stack:
for db_name in db_names:
stack.enter_context(transaction.atomic(db_name))
# Save deprecated form first to avoid ID conflicts
if processed_forms.deprecated:
FormAccessorSQL.update_form(processed_forms.deprecated,
publish_changes=False)
FormAccessorSQL.save_new_form(processed_forms.submitted)
if cases:
for case in cases:
CaseAccessorSQL.save_case(case)
if stock_result:
ledgers_to_save = stock_result.models_to_save
LedgerAccessorSQL.save_ledger_values(ledgers_to_save,
stock_result)
if cases:
sort_submissions = toggles.SORT_OUT_OF_ORDER_FORM_SUBMISSIONS_SQL.enabled(
processed_forms.submitted.domain, toggles.NAMESPACE_DOMAIN)
if sort_submissions:
for case in cases:
if SqlCaseUpdateStrategy(
case).reconcile_transactions_if_necessary():
CaseAccessorSQL.save_case(case)
def save_processed_models(cls, processed_forms, cases=None, stock_result=None, publish_to_kafka=True):
db_names = {processed_forms.submitted.db}
if processed_forms.deprecated:
db_names |= {processed_forms.deprecated.db}
if cases:
db_names |= {case.db for case in cases}
if stock_result:
db_names |= {
ledger_value.db for ledger_value in stock_result.models_to_save
}
with ExitStack() as stack:
for db_name in db_names:
stack.enter_context(transaction.atomic(db_name))
# Save deprecated form first to avoid ID conflicts
if processed_forms.deprecated:
FormAccessorSQL.update_form(processed_forms.deprecated, publish_changes=False)
FormAccessorSQL.save_new_form(processed_forms.submitted)
if cases:
for case in cases:
CaseAccessorSQL.save_case(case)
if stock_result:
ledgers_to_save = stock_result.models_to_save
LedgerAccessorSQL.save_ledger_values(ledgers_to_save, stock_result)
if cases:
sort_submissions = toggles.SORT_OUT_OF_ORDER_FORM_SUBMISSIONS_SQL.enabled(
processed_forms.submitted.domain, toggles.NAMESPACE_DOMAIN)
if sort_submissions:
for case in cases:
if SqlCaseUpdateStrategy(case).reconcile_transactions_if_necessary():
CaseAccessorSQL.save_case(case)
if publish_to_kafka:
try:
cls.publish_changes_to_kafka(processed_forms, cases, stock_result)
except Exception as e:
raise KafkaPublishingError(e)
