def test_balance_consumption(self): initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) final_amounts = [(p._id, float(50 - 10 * i)) for i, p in enumerate(self.products)] self.submit_xml_form(balance_submission(final_amounts)) for product, amt in final_amounts: self.check_product_stock(self.sp, product, amt, 0) inferred = amt - initial if should_use_sql_backend(self.domain): sql_txn = LedgerAccessors( self.domain.name).get_latest_transaction( self.sp.case_id, 'stock', product) self.assertEqual(inferred, sql_txn.delta) else: inferred_txn = StockTransaction.objects.get( case_id=self.sp.case_id, product_id=product, subtype=stockconst.TRANSACTION_SUBTYPE_INFERRED) self.assertEqual(Decimal(str(inferred)), inferred_txn.quantity) self.assertEqual(Decimal(str(amt)), inferred_txn.stock_on_hand) self.assertEqual(stockconst.TRANSACTION_TYPE_CONSUMPTION, inferred_txn.type)
def testArchiveLastForm(self): initial_amounts = [(p._id, float(100)) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) final_amounts = [(p._id, float(50)) for i, p in enumerate(self.products)] second_form_id = self.submit_xml_form(balance_submission(final_amounts)) def _assert_initial_state(): 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()) self.assertEqual(3, StockState.objects.filter(case_id=self.sp._id).count()) for state in StockState.objects.filter(case_id=self.sp._id): self.assertEqual(Decimal(50), state.stock_on_hand) self.assertIsNotNone(state.daily_consumption) # check initial setup _assert_initial_state() # archive and confirm commtrack data is deleted form = XFormInstance.get(second_form_id) form.archive() 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()) self.assertEqual(3, StockState.objects.filter(case_id=self.sp._id).count()) for state in StockState.objects.filter(case_id=self.sp._id): # balance should be reverted to 100 in the StockState self.assertEqual(Decimal(100), 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 form.unarchive() _assert_initial_state()
def test_balance_consumption_with_date(self): initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts), date_formatter=json_format_date) final_amounts = [(p._id, float(50 - 10*i)) for i, p in enumerate(self.products)] self.submit_xml_form(balance_submission(final_amounts), date_formatter=json_format_date) for product, amt in final_amounts: self.check_product_stock(self.sp, product, amt, 0)
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(): self.assertEqual( 3, len( self._get_all_ledger_transactions( Q(form_id=second_form_id)))) 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 = XFormInstance.objects.get_form(second_form_id, self.domain.name) with self.process_legder_changes: form.archive() self.assertEqual( 0, len(self._get_all_ledger_transactions(Q(form_id=second_form_id)))) 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 ledger value 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 self.process_legder_changes: form.unarchive() _assert_initial_state()
def testArchiveLastForm(self): initial_amounts = [(p._id, float(100)) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) final_amounts = [(p._id, float(50)) for i, p in enumerate(self.products)] second_form_id = self.submit_xml_form( balance_submission(final_amounts)) def _assert_initial_state(): 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()) self.assertEqual( 3, StockState.objects.filter(case_id=self.sp._id).count()) for state in StockState.objects.filter(case_id=self.sp._id): self.assertEqual(Decimal(50), state.stock_on_hand) self.assertIsNotNone(state.daily_consumption) # check initial setup _assert_initial_state() # archive and confirm commtrack data is deleted form = XFormInstance.get(second_form_id) form.archive() 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()) self.assertEqual( 3, StockState.objects.filter(case_id=self.sp._id).count()) for state in StockState.objects.filter(case_id=self.sp._id): # balance should be reverted to 100 in the StockState self.assertEqual(Decimal(100), 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 form.unarchive() _assert_initial_state()
def test_balance_consumption(self): initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) final_amounts = [(p._id, float(50 - 10 * i)) for i, p in enumerate(self.products)] self.submit_xml_form(balance_submission(final_amounts)) for product, amt in final_amounts: self.check_product_stock(self.sp, product, amt, 0) inferred = amt - initial sql_txn = LedgerAccessors(self.domain.name).get_latest_transaction( self.sp.case_id, 'stock', product) self.assertEqual(inferred, sql_txn.delta)
def test_balance_consumption(self): initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) final_amounts = [(p._id, float(50 - 10*i)) for i, p in enumerate(self.products)] self.submit_xml_form(balance_submission(final_amounts)) for product, amt in final_amounts: self.check_product_stock(self.sp, product, amt, 0) inferred = amt - initial inferred_txn = StockTransaction.objects.get(case_id=self.sp._id, product_id=product, subtype=stockconst.TRANSACTION_SUBTYPE_INFERRED) self.assertEqual(Decimal(str(inferred)), inferred_txn.quantity) self.assertEqual(Decimal(str(amt)), inferred_txn.stock_on_hand) self.assertEqual(stockconst.TRANSACTION_TYPE_CONSUMPTION, inferred_txn.type)
def test_blank_product_id(self): initial = float(100) balances = [('', initial)] instance_id = self.submit_xml_form(balance_submission(balances)) instance = FormAccessors(self.domain.name).get_form(instance_id) self.assertTrue(instance.is_error) self.assertTrue('MissingProductId' in instance.problem)
def test_blank_product_id(self): initial = float(100) balances = [('', initial)] instance_id = self.submit_xml_form(balance_submission(balances)) instance = XFormInstance.get(instance_id) self.assertEqual('XFormError', instance.doc_type) self.assertTrue('MissingProductId' in instance.problem)
def test_blank_quantities(self): # submitting a bunch of blank data shouldn't submit transactions # so lets submit some initial data and make sure we don't modify it # or have new transactions initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) trans_count = StockTransaction.objects.all().count() initial_amounts = [(p._id, '') for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) self.assertEqual(trans_count, StockTransaction.objects.all().count()) for product in self.products: self.check_product_stock(self.sp, product._id, 100, 0)
def test_xform_id_added_to_case_xform_list(self): initial_amounts = [(p._id, float(100)) for p in self.products] submissions = [balance_submission([amount]) for amount in initial_amounts] instance_id = self.submit_xml_form("".join(submissions), timestamp=datetime.utcnow() + timedelta(-30)) case = CommCareCase.get(self.sp.case_id) self.assertIn(instance_id, case.xform_ids)
def testArchiveOnlyForm(self): # check no data in stock states self.assertEqual(0, StockState.objects.filter(case_id=self.sp._id).count()) 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(): self.assertEqual(1, StockReport.objects.filter(form_id=form_id).count()) self.assertEqual(3, StockTransaction.objects.filter(report__form_id=form_id).count()) self.assertEqual(3, StockState.objects.filter(case_id=self.sp._id).count()) for state in StockState.objects.filter(case_id=self.sp._id): self.assertEqual(Decimal(100), state.stock_on_hand) _assert_initial_state() # archive and confirm commtrack data is cleared form = XFormInstance.get(form_id) form.archive() self.assertEqual(0, StockReport.objects.filter(form_id=form_id).count()) self.assertEqual(0, StockTransaction.objects.filter(report__form_id=form_id).count()) self.assertEqual(0, StockState.objects.filter(case_id=self.sp._id).count()) # unarchive and confirm commtrack data is restored form.unarchive() _assert_initial_state()
def test_blank_product_id(self): initial = float(100) balances = [("", initial)] instance_id = self.submit_xml_form(balance_submission(balances)) instance = XFormInstance.get(instance_id) self.assertEqual("XFormError", instance.doc_type) self.assertTrue("MissingProductId" in instance.problem)
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(): self.assertEqual( 3, len(self._get_all_ledger_transactions(Q(form_id=form_id)))) 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 = XFormInstance.objects.get_form(form_id, self.domain.name) form.archive() self.assertEqual( 0, len(ledger_accessors.get_ledger_values_for_case(self.sp.case_id))) self.assertEqual( 0, len(self._get_all_ledger_transactions(Q(form_id=form_id)))) # unarchive and confirm commtrack data is restored form.unarchive() _assert_initial_state()
def test_archived_product_submissions(self): """ This is basically the same as above, but separated to be verbose about what we are checking (and to make it easy to change the expected behavior if the requirements change soon. """ initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] final_amounts = [(p._id, float(50 - 10*i)) for i, p in enumerate(self.products)] self.submit_xml_form(balance_submission(initial_amounts)) self.products[1].archive() self.submit_xml_form(balance_submission(final_amounts)) for product, amt in final_amounts: self.check_product_stock(self.sp, product, amt, 0)
def test_transfer_source_only(self): initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) deductions = [(p._id, float(50 - 10*i)) for i, p in enumerate(self.products)] self.submit_xml_form(transfer_source_only(deductions)) for product, amt in deductions: self.check_product_stock(self.sp, product, initial-amt, -amt)
def test_transfer_enumerated(self): initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) receipts = [(p._id, float(50 - 10*i)) for i, p in enumerate(self.products)] self.submit_xml_form(receipts_enumerated(receipts)) for product, amt in receipts: self.check_product_stock(self.sp, product, initial + amt, amt)
def test_transfer_both(self): initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) transfers = [(p._id, float(50 - 10*i)) for i, p in enumerate(self.products)] self.submit_xml_form(transfer_both(transfers)) for product, amt in transfers: self.check_product_stock(self.sp, product, initial-amt, -amt) self.check_product_stock(self.sp2, product, amt, amt)
def test_xform_id_added_to_case_xform_list(self): initial_amounts = [(p._id, float(100)) for p in self.products] submissions = [balance_submission([amount]) for amount in initial_amounts] instance_id = self.submit_xml_form( ''.join(submissions), timestamp=datetime.utcnow() + timedelta(-30) ) case = CaseAccessors(self.domain.name).get_case(self.sp.case_id) self.assertIn(instance_id, case.xform_ids)
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 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 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 test_xform_id_added_to_case_xform_list_only_once(self): initial_amounts = [(p._id, float(100)) for p in self.products] submissions = [balance_submission([amount]) for amount in initial_amounts] case_block = CaseBlock(create=False, case_id=self.sp.case_id, user_id="jack", update={"test": "1"}).as_string() instance_id = self.submit_xml_form( "".join([case_block] + submissions), timestamp=datetime.utcnow() + timedelta(-30) ) case = CommCareCase.get(self.sp.case_id) self.assertIn(instance_id, case.xform_ids) # make sure the ID only got added once self.assertEqual(len(case.xform_ids), len(set(case.xform_ids)))
def test_balance_submit_multiple_stocks(self): def _random_amounts(): return [(p._id, float(random.randint(0, 100))) for i, p in enumerate(self.products)] section_ids = ('stock', 'losses', 'consumption') stock_amounts = [(id, _random_amounts()) for id in section_ids] for section_id, amounts in stock_amounts: self.submit_xml_form(balance_submission(amounts, section_id=section_id)) for section_id, amounts in stock_amounts: for product, amt in amounts: self.check_product_stock(self.sp, product, amt, 0, section_id)
def test_balance_consumption(self): initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) final_amounts = [(p._id, float(50 - 10*i)) for i, p in enumerate(self.products)] self.submit_xml_form(balance_submission(final_amounts)) for product, amt in final_amounts: self.check_product_stock(self.sp, product, amt, 0) inferred = amt - initial if should_use_sql_backend(self.domain.name): sql_txn = LedgerAccessors(self.domain.name).get_latest_transaction( self.sp.case_id, 'stock', product ) self.assertEqual(inferred, sql_txn.delta) else: inferred_txn = StockTransaction.objects.get( case_id=self.sp.case_id, product_id=product, subtype=stockconst.TRANSACTION_SUBTYPE_INFERRED ) self.assertEqual(Decimal(str(inferred)), inferred_txn.quantity) self.assertEqual(Decimal(str(amt)), inferred_txn.stock_on_hand) self.assertEqual(stockconst.TRANSACTION_TYPE_CONSUMPTION, inferred_txn.type)
def test_transfer_first_doc_order(self): # first set to 100 initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) # then mark some receipts transfers = [(p._id, float(50 - 10*i + 3)) for i, p in enumerate(self.products)] # then set to 50 final = float(50) balance_amounts = [(p._id, final) for p in self.products] self.submit_xml_form(transfer_first(transfers, balance_amounts)) for product, amt in transfers: self.check_product_stock(self.sp, product, final, 0)
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 = CommCareCase.get(self.sp.case_id) self.assertIn(instance_id, case.xform_ids) form = XFormInstance.get(instance_id) form.archive() case = CommCareCase.get(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 = CommCareCase.objects.get_case(self.sp.case_id, self.domain.name) self.assertIn(instance_id, case.xform_ids) form = XFormInstance.objects.get_form(instance_id, self.domain.name) form.archive() case = CommCareCase.objects.get_case(self.sp.case_id, self.domain.name) self.assertNotIn(instance_id, case.xform_ids)
def test_transfer_first_doc_order(self): # first set to 100 initial = float(100) initial_amounts = [(p._id, initial) for p in self.products] self.submit_xml_form(balance_submission(initial_amounts)) # then mark some receipts transfers = [(p._id, float(50 - 10*i)) for i, p in enumerate(self.products)] # then set to 50 final = float(50) balance_amounts = [(p._id, final) for p in self.products] self.submit_xml_form(transfer_first(transfers, balance_amounts)) for product, amt in transfers: self.check_product_stock(self.sp, product, final, 0)
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_xform_id_added_to_case_xform_list_only_once(self): initial_amounts = [(p._id, float(100)) for p in self.products] submissions = [balance_submission([amount]) for amount in initial_amounts] case_block = CaseBlock( create=False, case_id=self.sp.case_id, user_id='jack', update={'test': '1'} ).as_string().decode('utf-8') instance_id = self.submit_xml_form( ''.join([case_block] + submissions), timestamp=datetime.utcnow() + timedelta(-30) ) case = CaseAccessors(self.domain.name).get_case(self.sp.case_id) self.assertIn(instance_id, case.xform_ids) # make sure the ID only got added once self.assertEqual(len(case.xform_ids), len(set(case.xform_ids)))
def test_xform_id_added_to_case_xform_list_only_once(self): initial_amounts = [(p._id, float(100)) for p in self.products] submissions = [balance_submission([amount]) for amount in initial_amounts] case_block = CaseBlock( create=False, case_id=self.sp.case_id, user_id='jack', update={'test': '1'} ).as_string() instance_id = self.submit_xml_form( ''.join([case_block] + submissions), timestamp=datetime.utcnow() + timedelta(-30) ) case = CaseAccessors(self.domain.name).get_case(self.sp.case_id) self.assertIn(instance_id, case.xform_ids) # make sure the ID only got added once self.assertEqual(len(case.xform_ids), len(set(case.xform_ids)))
def test_submit_bad_case_id(self): instance_id = uuid.uuid4().hex amounts = [(p._id, float(i*10)) for i, p in enumerate(self.products)] xml_stub = balance_submission(amounts) instance = submission_wrap( instance_id, self.products, self.user, 'missing', 'missing-too', xml_stub, ) submit_form_locally( instance=instance, domain=self.domain.name, ) form = XFormInstance.get(instance_id) self.assertEqual('XFormError', form.doc_type) self.assertTrue('IllegalCaseId' in form.problem)
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()
def test_blank_product_id(self): initial = float(100) balances = [('', initial)] with self.assertRaises(MissingProductId): # todo: if we ever want to fail more gracefully we can catch this exception and change this test self.submit_xml_form(balance_submission(balances))
def test_balance_submit_date(self): amounts = [(p._id, float(i * 10)) for i, p in enumerate(self.products)] self.submit_xml_form(balance_submission(amounts), date_formatter=json_format_date) for product, amt in amounts: self.check_product_stock(self.sp, product, amt, 0)
def test_balance_submit(self): amounts = [(p._id, float(i*10)) for i, p in enumerate(self.products)] self.submit_xml_form(balance_submission(amounts)) for product, amt in amounts: self.check_product_stock(self.sp, product, amt, 0)