def setUpClass(cls): super(LedgerTests, cls).setUpClass() FormProcessorTestUtils.delete_all_cases(DOMAIN) FormProcessorTestUtils.delete_all_xforms(DOMAIN) cls.product_a = make_product(DOMAIN, 'A Product', 'prodcode_a') cls.product_b = make_product(DOMAIN, 'B Product', 'prodcode_b') cls.product_c = make_product(DOMAIN, 'C Product', 'prodcode_c')
def setUpClass(cls): super(LedgerDBAccessorTest, cls).setUpClass() cls.domain = uuid.uuid4().hex with override_settings(TESTS_SHOULD_USE_SQL_BACKEND=True): FormProcessorTestUtils.delete_all_cases_forms_ledgers(cls.domain) cls.product_a = make_product(cls.domain, 'A Product', 'prodcode_a') cls.product_b = make_product(cls.domain, 'B Product', 'prodcode_b')
def setUpClass(cls): super(LedgerDBAccessorTest, cls).setUpClass() cls.domain = uuid.uuid4().hex FormProcessorTestUtils.delete_all_cases_forms_ledgers(cls.domain) cls.product_a = make_product(cls.domain, 'A Product', 'prodcode_a') cls.product_b = make_product(cls.domain, 'B Product', 'prodcode_b') cls.product_c = make_product(cls.domain, 'C Product', 'prodcode_c')
def setUp(self): super(LedgerMigrationTests, self).setUp() self.liquorice = make_product(self.domain_name, 'liquorice', 'liquorice') self.sherbert = make_product(self.domain_name, 'sherbert', 'sherbert') self.jelly_babies = make_product(self.domain_name, 'jelly babies', 'jbs')
def setUpClass(cls): super(LedgerDBAccessorTest, cls).setUpClass() cls.domain = uuid.uuid4().hex with override_settings(TESTS_SHOULD_USE_SQL_BACKEND=True): FormProcessorTestUtils.delete_all_cases_forms_ledgers(cls.domain) cls.product_a = make_product(cls.domain, 'A Product', 'prodcode_a') cls.product_b = make_product(cls.domain, 'B Product', 'prodcode_b') cls.product_c = make_product(cls.domain, 'C Product', 'prodcode_c')
def setUpClass(cls): cls.domain = create_domain(TEST_DOMAIN) cls.couch_user = WebUser.create(None, "report_test", "foobar") cls.couch_user.add_domain_membership(TEST_DOMAIN, is_admin=True) cls.couch_user.save() cls.products = { 'pA': make_product(TEST_DOMAIN, 'prod A', 'pA'), 'pB': make_product(TEST_DOMAIN, 'prod B', 'pB') } test_setup = { 'A': { 'A-a': { 'A-a-1': {'pA': 4, 'pB': 0}, 'A-a-2': {'pB': 3}, }, 'A-b': { 'A-b-1': {'pA': 2} } }, 'B': { 'B-a': { 'B-a-1': {'pA': 1, 'pB': 1} } } } cls.sites = {} cls.regions = {} cls.districts = {} for region_name, districts in test_setup.items(): region = make_loc(region_name, type='region') cls.regions[region_name] = region for district_name, sites in districts.items(): district = make_loc(district_name, type='district', parent=region) cls.districts[district_name] = district for site_name, products in sites.items(): site = make_loc(site_name, type='site', parent=district, domain=TEST_DOMAIN) cls.sites[site_name] = (site, products) supply_point = make_supply_point(TEST_DOMAIN, site) for p_code, stock in products.items(): prod = cls.products[p_code] StockState.objects.create( section_id='stock', case_id=supply_point._id, product_id=prod._id, stock_on_hand=stock, last_modified_date=datetime.utcnow(), )
def setUpClass(cls): super(TestSQLDumpLoadShardedModels, cls).setUpClass() cls.factory = CaseFactory(domain=cls.domain_name) cls.form_accessors = FormAccessors(cls.domain_name) cls.case_accessors = CaseAccessors(cls.domain_name) cls.product = make_product(cls.domain_name, 'A Product', 'prodcode_a') cls.default_objects_counts.update({SQLProduct: 1})
def setUpClass(cls): cls.domain = create_domain(TEST_DOMAIN) cls.couch_user = WebUser.create(None, "report_test", "foobar") cls.couch_user.add_domain_membership(TEST_DOMAIN, is_admin=True) cls.couch_user.save() cls.products = { 'pA': make_product(TEST_DOMAIN, 'prod A', 'pA'), 'pB': make_product(TEST_DOMAIN, 'prod B', 'pB') } test_setup = { 'A': { 'A-a': { 'A-a-1': {'pA': 4, 'pB': 0}, 'A-a-2': {'pB': 3}, }, 'A-b': { 'A-b-1': {'pA': 2} } }, 'B': { 'B-a': { 'B-a-1': {'pA': 1, 'pB': 1} } } } cls.sites = {} cls.regions = {} cls.districts = {} for region_name, districts in test_setup.items(): region = make_loc(region_name, type='region') cls.regions[region_name] = region for district_name, sites in districts.items(): district = make_loc(district_name, type='district', parent=region) cls.districts[district_name] = district for site_name, products in sites.items(): site = make_loc(site_name, type='site', parent=district) cls.sites[site_name] = (site, products) supply_point = make_supply_point(TEST_DOMAIN, site) for p_code, stock in products.items(): prod = cls.products[p_code] spp = make_supply_point_product(supply_point, prod._id) update_supply_point_product_stock_level(spp, stock)
def setUp(self): self.domain = 'asldkjf-domain' self.case = CommCareCase(domain=self.domain) self.case.save() self.product = make_product(self.domain, 'Product Name', 'prodcode') self._stock_state_key = dict(section_id='stock', case_id=self.case.get_id, product_id=self.product.get_id)
def setUp(self): self.domain = 'asldkjf-domain' self.case = CommCareCase(domain=self.domain) self.case.save() self.product = make_product(self.domain, 'Product Name', 'prodcode') self._stock_state_key = dict( section_id='stock', case_id=self.case.get_id, product_id=self.product.get_id )
def create_form_with_duplicate_stock_transaction(self): from corehq.apps.commtrack.helpers import make_product from corehq.apps.commtrack.processing import process_stock thing1 = make_product(self.domain_name, 'thing-1', 'thing-1') self.submit_form(LEDGER_FORM.replace("thing-1", thing1._id)) stock_result = process_stock([self._get_form("ledger-form")]) stock_result.populate_models() for model in stock_result.models_to_save: model.save() return thing1._id
def setUp(self): self.domain = create_domain("locations-test") self.domain.save() LocationType.objects.get_or_create(domain=self.domain.name, name="outlet") make_product(self.domain.name, "apple", "apple") make_product(self.domain.name, "orange", "orange") make_product(self.domain.name, "banana", "banana") make_product(self.domain.name, "pear", "pear") couch_loc = make_loc("loc", type="outlet", domain=self.domain.name) self.loc = couch_loc.sql_location
def test_duplicate_ledger_published(self): # this test also only runs on the sql backend for reasons described in test_duplicate_case_published # setup products and case product_a = make_product(self.domain, 'A Product', 'prodcode_a') product_b = make_product(self.domain, 'B Product', 'prodcode_b') case_id = uuid.uuid4().hex form_xml = get_simple_form_xml(uuid.uuid4().hex, case_id) submit_form_locally(form_xml, domain=self.domain) # submit ledger data balances = ( (product_a._id, 100), (product_b._id, 50), ) ledger_blocks = [ get_single_balance_block(case_id, prod_id, balance) for prod_id, balance in balances ] form = submit_case_blocks(ledger_blocks, self.domain)[0] # submit duplicate with process_pillow_changes(self.ledger_pillow): with process_pillow_changes('DefaultChangeFeedPillow'): dupe_form = submit_form_locally(form.get_xml(), domain=self.domain).xform self.assertTrue(dupe_form.is_duplicate) # confirm republished ledger_meta_a = self.processor.changes_seen[0].metadata ledger_meta_b = self.processor.changes_seen[1].metadata format_id = lambda product_id: '{}/{}/{}'.format( case_id, 'stock', product_id) expected_ids = {format_id(product_a._id), format_id(product_b._id)} for meta in [ledger_meta_a, ledger_meta_b]: self.assertTrue(meta.document_id in expected_ids) expected_ids.remove(meta.document_id) self.assertEqual(self.domain, meta.domain) # cleanup product_a.delete() product_b.delete()
def test_duplicate_ledger_published(self): # this test also only runs on the sql backend for reasons described in test_duplicate_case_published # setup products and case product_a = make_product(self.domain, 'A Product', 'prodcode_a') product_b = make_product(self.domain, 'B Product', 'prodcode_b') case_id = uuid.uuid4().hex form_xml = get_simple_form_xml(uuid.uuid4().hex, case_id) submit_form_locally(form_xml, domain=self.domain)[1] # submit ledger data balances = ( (product_a._id, 100), (product_b._id, 50), ) ledger_blocks = [ get_single_balance_block(case_id, prod_id, balance) for prod_id, balance in balances ] form = submit_case_blocks(ledger_blocks, self.domain)[0] # submit duplicate with process_kafka_changes(self.ledger_pillow): with process_couch_changes('DefaultChangeFeedPillow'): dupe_form = submit_form_locally(form.get_xml(), domain=self.domain)[1] self.assertTrue(dupe_form.is_duplicate) # confirm republished ledger_meta_a = self.processor.changes_seen[0].metadata ledger_meta_b = self.processor.changes_seen[1].metadata format_id = lambda product_id: '{}/{}/{}'.format(case_id, 'stock', product_id) expected_ids = {format_id(product_a._id), format_id(product_b._id)} for meta in [ledger_meta_a, ledger_meta_b]: self.assertTrue(meta.document_id in expected_ids) expected_ids.remove(meta.document_id) self.assertEqual(self.domain, meta.domain) # cleanup product_a.delete() product_b.delete()
def setUpClass(cls): cls.domain = create_domain(TEST_DOMAIN) cls.couch_user = WebUser.create(None, "report_test", "foobar") cls.couch_user.add_domain_membership(TEST_DOMAIN, is_admin=True) cls.couch_user.save() cls.products = { "pA": make_product(TEST_DOMAIN, "prod A", "pA"), "pB": make_product(TEST_DOMAIN, "prod B", "pB"), } test_setup = { "A": {"A-a": {"A-a-1": {"pA": 4, "pB": 0}, "A-a-2": {"pB": 3}}, "A-b": {"A-b-1": {"pA": 2}}}, "B": {"B-a": {"B-a-1": {"pA": 1, "pB": 1}}}, } cls.sites = {} cls.regions = {} cls.districts = {} for region_name, districts in test_setup.items(): region = make_loc(region_name, type="region") cls.regions[region_name] = region for district_name, sites in districts.items(): district = make_loc(district_name, type="district", parent=region) cls.districts[district_name] = district for site_name, products in sites.items(): site = make_loc(site_name, type="site", parent=district, domain=TEST_DOMAIN) cls.sites[site_name] = (site, products) supply_point = make_supply_point(TEST_DOMAIN, site) for p_code, stock in products.items(): prod = cls.products[p_code] StockState.objects.create( section_id="stock", case_id=supply_point._id, product_id=prod._id, stock_on_hand=stock, last_modified_date=datetime.utcnow(), )
def setUp(self): self.domain = create_domain('locations-test') self.domain.save() LocationType.objects.get_or_create( domain=self.domain.name, name='outlet', ) make_product(self.domain.name, 'apple', 'apple') make_product(self.domain.name, 'orange', 'orange') make_product(self.domain.name, 'banana', 'banana') make_product(self.domain.name, 'pear', 'pear') self.loc = make_loc('loc', type='outlet', domain=self.domain.name)
def test_duplicate_ledger_published(self): # setup products and case product_a = make_product(self.domain, 'A Product', 'prodcode_a') product_b = make_product(self.domain, 'B Product', 'prodcode_b') case_id = uuid.uuid4().hex form_xml = get_simple_form_xml(uuid.uuid4().hex, case_id) submit_form_locally(form_xml, domain=self.domain)[1] # submit ledger data balances = ( (product_a._id, 100), (product_b._id, 50), ) ledger_blocks = [ get_single_balance_block(case_id, prod_id, balance) for prod_id, balance in balances ] form = submit_case_blocks(ledger_blocks, self.domain) # submit duplicate ledger_consumer = get_test_kafka_consumer(topics.LEDGER) dupe_form = submit_form_locally(form.get_xml(), domain=self.domain)[1] self.assertTrue(dupe_form.is_duplicate) # confirm republished ledger_meta_a = change_meta_from_kafka_message(ledger_consumer.next().value) ledger_meta_b = change_meta_from_kafka_message(ledger_consumer.next().value) format_id = lambda product_id: '{}/{}/{}'.format(case_id, 'stock', product_id) expected_ids = {format_id(product_a._id), format_id(product_b._id)} for meta in [ledger_meta_a, ledger_meta_b]: self.assertTrue(meta.document_id in expected_ids) expected_ids.remove(meta.document_id) self.assertEqual(self.domain, meta.domain) # cleanup product_a.delete() product_b.delete()
def setUp(self): super(RebuildStockStateTest, self).setUp() self.domain = 'asldkjf-domain' self.case = CaseFactory(domain=self.domain).create_case() self.product = make_product(self.domain, 'Product Name', 'prodcode') self._stock_state_key = dict(section_id='stock', case_id=self.case.case_id, product_id=self.product.get_id) self.unique_reference = UniqueLedgerReference( case_id=self.case.case_id, section_id='stock', entry_id=self.product.get_id) self.ledger_processor = FormProcessorInterface( self.domain).ledger_processor
def setUp(self): super(RebuildStockStateTest, self).setUp() self.domain = 'asldkjf-domain' self.case = CaseFactory(domain=self.domain).create_case() self.product = make_product(self.domain, 'Product Name', 'prodcode') self._stock_state_key = dict( section_id='stock', case_id=self.case.case_id, product_id=self.product.get_id ) self.unique_reference = UniqueLedgerReference( case_id=self.case.case_id, section_id='stock', entry_id=self.product.get_id ) self.ledger_processor = FormProcessorInterface(self.domain).ledger_processor
def setUpClass(cls): super(StockStatusDataSourceTests, cls).setUpClass() cls.domain = uuid.uuid4().hex cls.project = bootstrap_domain(cls.domain) cls.interface = SupplyInterface(cls.domain) cls.product = make_product(cls.domain, 'A Product', 'prodcode_a') cls.location = make_loc('1234', name='ben', domain=cls.domain) cls.location2 = make_loc('1235', name='ken', domain=cls.domain) cls.supply_point = cls.location.linked_supply_point() submit_case_blocks( [get_single_balance_block(cls.supply_point.case_id, cls.product._id, 50)], cls.domain )
def setUp(self): self.domain = create_domain('locations-test') self.domain.locations_enabled = True self.domain.location_types = [ LocationType( name='outlet', allowed_parents=[] ), ] self.domain.save() make_product(self.domain.name, 'apple', 'apple') make_product(self.domain.name, 'orange', 'orange') make_product(self.domain.name, 'banana', 'banana') make_product(self.domain.name, 'pear', 'pear') couch_loc = make_loc('loc', type='outlet', domain=self.domain.name) self.loc = couch_loc.sql_location
def create_docs(cls, domain, count): from corehq.apps.commtrack.tests.util import get_single_balance_block from corehq.apps.hqcase.utils import submit_case_blocks from corehq.apps.commtrack.helpers import make_product from corehq.form_processor.parsers.ledgers.helpers import UniqueLedgerReference cls.product = make_product(cls.domain, 'A Product', 'prodcode_a') factory = CaseFactory(cls.domain) case_ids = [factory.create_case().case_id for i in range(count)] for case_id in case_ids: submit_case_blocks([ get_single_balance_block(case_id, cls.product._id, 10) ], domain) return [ UniqueLedgerReference(case_id, 'stock', cls.product._id).as_id() for case_id in case_ids ]
def make_product(self, name="thing-1"): from corehq.apps.commtrack.helpers import make_product return make_product(self.domain_name, name, name)
def setUpClass(cls): super(LedgerTests, cls).setUpClass() cls.product_a = make_product(DOMAIN, 'A Product', 'prodcode_a') cls.product_b = make_product(DOMAIN, 'B Product', 'prodcode_b') cls.product_c = make_product(DOMAIN, 'C Product', 'prodcode_c')
def setUpClass(cls): super(TestSupplyAccessors, cls).setUpClass() cls.product_a = make_product(cls.domain, 'A Product', 'prodcode_a') cls.product_b = make_product(cls.domain, 'B Product', 'prodcode_b')
def setUpClass(cls): super(TestLedgerDocumentStore, cls).setUpClass() cls.product_a = make_product(DOMAIN, 'A Product', uuid.uuid4().hex)
def setUpClass(cls): cls.product_a = make_product(cls.domain, 'A Product', 'prodcode_a') cls.product_b = make_product(cls.domain, 'B Product', 'prodcode_b')
def setUpClass(cls): super(LedgerPillowTestCouch, cls).setUpClass() from corehq.apps.commtrack.helpers import make_product product = make_product(cls.domain, 'Product A', 'prod_a') cls.product_id = product._id
def setUpClass(cls): FormProcessorTestUtils.delete_all_cases(DOMAIN) FormProcessorTestUtils.delete_all_xforms(DOMAIN) cls.product = make_product(DOMAIN, 'A Product', 'prodcode')
def setUpClass(cls): super(LedgerAccessorErrorTests, cls).setUpClass() cls.domain = uuid.uuid4().hex cls.product = make_product(cls.domain, 'A Product', 'prodcode_a')
def setUpClass(cls): from corehq.apps.commtrack.helpers import make_product product = make_product(cls.domain, 'Product A', 'prod_a') cls.product_id = product._id
def setUp(self): self.domain = bootstrap_domain(TEST_DOMAIN) self.loc = make_loc('loc1') self.sp = make_supply_point(TEST_DOMAIN, self.loc) self.product = make_product(TEST_DOMAIN, 'product 1', 'p1')
def setUp(self): self.domain = "asldkjf-domain" self.case = CommCareCase(domain=self.domain) self.case.save() self.product = make_product(self.domain, "Product Name", "prodcode") self._stock_state_key = dict(section_id="stock", case_id=self.case.get_id, product_id=self.product.get_id)
def setUpClass(cls): super(LedgerPillowTest, cls).setUpClass() from corehq.apps.commtrack.helpers import make_product product = make_product(cls.domain, 'Product A', 'prod_a') cls.product_id = product._id
def setUp(self): self.loc = make_loc('loc1') self.sp = make_supply_point(TEST_DOMAIN, self.loc) self.product = make_product(TEST_DOMAIN, 'product 1', 'p1')