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):
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 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):
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 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 setUpClass(cls):
super(LedgerAccessorErrorTests, cls).setUpClass()
cls.domain = uuid.uuid4().hex
cls.product = make_product(cls.domain, 'A Product', 'prodcode_a')
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(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):
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 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 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')
