def setUpClass(cls):
super(HandlerTest, cls).setUpClass()
cls.domain = 'ews-handler-test'
bootstrap_domain(cls.domain)
cls.create_account_and_subscription(cls.domain)
cls.domain_obj = Domain.get_by_name(cls.domain)
cls.loc = make_loc(code="garms", name="Test RMS", type="Regional Medical Store", domain=cls.domain)
cls.user = bootstrap_user(username='******', phone_number='323232', domain=cls.domain,
home_loc=cls.loc)
def setUp(self):
super(HandlerTest, self).setUp()
self.backend, self.backend_mapping = setup_default_sms_test_backend()
self.domain = 'ews-handler-test'
bootstrap_domain(self.domain)
self.create_account_and_subscription(self.domain)
self.domain_obj = Domain.get_by_name(self.domain)
self.loc = make_loc(code="garms", name="Test RMS", type="Regional Medical Store", domain=self.domain)
self.user = bootstrap_user(username='******', phone_number='323232', domain=self.domain,
home_loc=self.loc)
def setUp(self):
self.datapath = os.path.join(os.path.dirname(__file__), 'data')
bootstrap_domain(TEST_DOMAIN)
delete_all_cases()
for loc in Location.by_domain(TEST_DOMAIN):
loc.delete()
LocationType.objects.get_or_create(
domain=TEST_DOMAIN,
name="Lvl3 Hospital",
)
def setUpClass(cls):
super(HandlerTest, cls).setUpClass()
cls.domain = 'ews-handler-test'
bootstrap_domain(cls.domain)
cls.create_account_and_subscription(cls.domain)
cls.domain_obj = Domain.get_by_name(cls.domain)
cls.loc = make_loc(code="garms",
name="Test RMS",
type="Regional Medical Store",
domain=cls.domain)
cls.user = bootstrap_user(username='******',
phone_number='323232',
domain=cls.domain,
home_loc=cls.loc)
def setUp(self):
super(HandlerTest, self).setUp()
self.backend, self.backend_mapping = setup_default_sms_test_backend()
self.domain = 'ews-handler-test'
bootstrap_domain(self.domain)
self.create_account_and_subscription(self.domain)
self.domain_obj = Domain.get_by_name(self.domain)
self.loc = make_loc(code="garms",
name="Test RMS",
type="Regional Medical Store",
domain=self.domain)
self.user = bootstrap_user(username='******',
phone_number='323232',
domain=self.domain,
home_loc=self.loc)
def setUp(self):
self.domain_obj = bootstrap_domain(self.domain)
self.user = create_restore_user(self.domain, 'user', '123')
self.location_types = setup_location_types_with_structure(
self.domain, self.location_type_structure)
self.locations = setup_locations_with_structure(
self.domain, self.location_structure)
def setUp(self):
super(XMLTest, self).setUp()
self.domain = util.bootstrap_domain(util.TEST_DOMAIN)
util.bootstrap_location_types(self.domain.name)
util.bootstrap_products(self.domain.name)
self.products = sorted(Product.by_domain(self.domain.name),
key=lambda p: p._id)
self.ct_settings = SQLCommtrackConfig.for_domain(self.domain.name)
self.ct_settings.sqlconsumptionconfig = SQLConsumptionConfig(
min_transactions=0,
min_window=0,
optimal_window=60,
)
self.ct_settings.save()
self.ct_settings.sqlconsumptionconfig.commtrack_settings = self.ct_settings
self.ct_settings.sqlconsumptionconfig.save()
self.domain = Domain.get(self.domain._id)
self.loc = make_loc('loc1')
self.sp = self.loc.linked_supply_point()
self.users = [
util.bootstrap_user(self, **user_def)
for user_def in self.user_definitions
]
self.user = self.users[0]
def testOTASettings(self):
domain = bootstrap_domain()
ct_settings = CommtrackConfig.for_domain(domain.name)
ct_settings.consumption_config = ConsumptionConfig(
min_transactions=10,
min_window=20,
optimal_window=60,
)
ct_settings.ota_restore_config = StockRestoreConfig(
section_to_consumption_types={'stock': 'consumption'},
)
set_default_monthly_consumption_for_domain(domain.name, 5 * DAYS_IN_MONTH)
restore_settings = ct_settings.get_ota_restore_settings()
self.assertEqual(1, len(restore_settings.section_to_consumption_types))
self.assertEqual('consumption', restore_settings.section_to_consumption_types['stock'])
self.assertEqual(10, restore_settings.consumption_config.min_periods)
self.assertEqual(20, restore_settings.consumption_config.min_window)
self.assertEqual(60, restore_settings.consumption_config.max_window)
self.assertEqual(150, restore_settings.consumption_config.default_monthly_consumption_function('foo', 'bar'))
self.assertFalse(restore_settings.force_consumption_case_filter(CommCareCase(type='force-type')))
self.assertEqual(0, len(restore_settings.default_product_list))
ct_settings.ota_restore_config.force_consumption_case_types=['force-type']
ct_settings.ota_restore_config.use_dynamic_product_list=True
restore_settings = ct_settings.get_ota_restore_settings()
self.assertTrue(restore_settings.force_consumption_case_filter(CommCareCase(type='force-type')))
self.assertEqual(3, len(restore_settings.default_product_list))
def test_location_restricted_cases(self):
domain_obj = bootstrap_domain(self.domain)
self.addCleanup(domain_obj.delete)
location_type_names = ['state', 'county', 'city']
location_structure = [('Massachusetts', [('Middlesex', [
('Cambridge', []),
('Somerville', []),
]), ('Suffolk', [
('Boston', []),
])])]
locations = setup_locations_and_types(self.domain, location_type_names,
[], location_structure)[1]
middlesex_user = CommCareUser.create(self.domain, 'guy-from-middlesex',
'***', None, None)
middlesex_user.add_to_assigned_locations(locations['Middlesex'])
restrict_user_by_location(self.domain, middlesex_user)
fake_request = MagicMock()
fake_request.domain = self.domain
fake_request.couch_user = middlesex_user
self._send_case_to_es(owner_id=locations['Boston'].get_id)
middlesex_case = self._send_case_to_es(
owner_id=locations['Middlesex'].get_id)
cambridge_case = self._send_case_to_es(
owner_id=locations['Cambridge'].get_id)
returned_case_ids = query_location_restricted_cases(
CaseES().domain(self.domain), fake_request).get_ids()
self.assertItemsEqual(returned_case_ids,
[middlesex_case.case_id, cambridge_case.case_id])
def setUpClass(cls):
cls.domain_obj = bootstrap_domain(cls.domain)
cls.location_types, cls.locations = setup_locations_and_types(
cls.domain,
cls.location_type_names,
cls.stock_tracking_types,
cls.location_structure,
)
def setUp(self):
self.domain_obj = bootstrap_domain(self.domain)
self.location_types, self.locations = setup_locations_and_types(
self.domain,
self.location_type_names,
self.stock_tracking_types,
self.location_structure,
)
def setUp(self):
self.domain_obj = bootstrap_domain(self.domain)
self.location_types, self.locations = setup_locations_and_types(
self.domain,
self.location_type_names,
self.stock_tracking_types,
self.location_structure,
)
def setUpClass(cls):
cls.domain_obj = bootstrap_domain(cls.domain)
cls.location_types, cls.locations = setup_locations_and_types(
cls.domain,
cls.location_type_names,
cls.stock_tracking_types,
cls.location_structure,
)
def setUp(self):
super(ForkedHierarchiesTest, self).setUp()
self.domain = 'test'
self.domain_obj = bootstrap_domain(self.domain)
self.addCleanup(self.domain_obj.delete)
self.user = create_restore_user(self.domain, 'user', '123')
location_type_structure = [
LocationTypeStructure('ctd', [
LocationTypeStructure('sto', [
LocationTypeStructure('cto', [
LocationTypeStructure('dto', [
LocationTypeStructure('tu', [
LocationTypeStructure('phi', []),
LocationTypeStructure('dmc', []),
]),
])
]),
LocationTypeStructure('drtb', []),
LocationTypeStructure('cdst', []),
])
])
]
location_structure = [
LocationStructure('CTD', 'ctd', [
LocationStructure('STO', 'sto', [
LocationStructure('CTO', 'cto', [
LocationStructure('DTO', 'dto', [
LocationStructure('TU', 'tu', [
LocationStructure('PHI', 'phi', []),
LocationStructure('DMC', 'dmc', []),
]),
])
]),
LocationStructure('DRTB', 'drtb', []),
LocationStructure('CDST', 'cdst', []),
]),
LocationStructure('STO1', 'sto', [
LocationStructure('CTO1', 'cto', [
LocationStructure('DTO1', 'dto', [
LocationStructure('TU1', 'tu', [
LocationStructure('PHI1', 'phi', []),
LocationStructure('DMC1', 'dmc', []),
]),
])
]),
LocationStructure('DRTB1', 'drtb', []),
LocationStructure('CDST1', 'cdst', []),
])
])
]
location_metadata = {'is_test': 'no', 'nikshay_code': 'nikshay_code'}
setup_location_types_with_structure(self.domain,
location_type_structure),
self.locations = setup_locations_with_structure(
self.domain, location_structure, location_metadata)
def setUpClass(cls):
super(LocationHierarchyTestCase, cls).setUpClass()
cls.domain_obj = bootstrap_domain(cls.domain)
cls.location_types, cls.locations = setup_locations_and_types(
cls.domain,
cls.location_type_names,
cls.stock_tracking_types,
cls.location_structure,
)
def setUp(self):
self.domain = 'supply-point-dbaccessors'
self.project = bootstrap_domain(self.domain)
self.locations = [
make_loc('1234', name='ben', domain=self.domain),
make_loc('1235', name='ben', domain=self.domain),
make_loc('1236', name='ben', domain=self.domain),
]
def setUpClass(cls):
super(LocationHierarchyTestCase, cls).setUpClass()
cls.domain_obj = bootstrap_domain(cls.domain)
cls.location_types, cls.locations = setup_locations_and_types(
cls.domain,
cls.location_type_names,
cls.stock_tracking_types,
cls.location_structure,
)
def test_programs(self):
self.domain = bootstrap_domain(TEST_DOMAIN)
self.addCleanup(self.domain.delete)
bootstrap_products(self.domain.name)
self.products = sorted(Product.by_domain(self.domain.name), key=lambda p: p._id)
self.default_program = Program.by_domain(self.domain.name, wrap=True).one()
self.new_program = make_program(
self.domain.name,
'new program',
'newprogram'
)
self.assertTrue(self.default_program.default)
self.assertFalse(self.new_program.default)
with self.assertRaises(Exception) as context:
self.default_program.delete()
self.assertEqual(six.text_type(context.exception), 'You cannot delete the default program')
# assign some product to the new program
self.products[0].program_id = self.new_program._id
self.products[0].save()
# make sure start state is okay
self.assertEqual(
2,
len(Program.by_domain(self.domain.name))
)
self.assertEqual(2, self.default_program.get_products_count())
self.assertEqual(1, self.new_program.get_products_count())
self.assertEqual(
self.new_program._id,
self.products[0].program_id
)
self.assertEqual(
self.new_program._id,
SQLProduct.objects.get(product_id=self.products[0]._id).program_id
)
# stash the id before we delete
new_program_id = self.new_program._id
self.new_program.delete()
with self.assertRaises(ResourceNotFound):
Program.get(new_program_id)
self.assertEqual(1, len(Program.by_domain(self.domain.name)))
self.assertEqual(3, self.default_program.get_products_count())
self.assertEqual(
self.default_program._id,
Product.get(self.products[0]._id).program_id
)
self.assertEqual(
self.default_program._id,
SQLProduct.objects.get(product_id=self.products[0]._id).program_id
)
def setUp(self):
super(ForkedHierarchiesTest, self).setUp()
self.domain = 'test'
self.domain_obj = bootstrap_domain(self.domain)
self.addCleanup(self.domain_obj.delete)
self.user = create_restore_user(self.domain, 'user', '123')
location_type_structure = [
LocationTypeStructure('ctd', [
LocationTypeStructure('sto', [
LocationTypeStructure('cto', [
LocationTypeStructure('dto', [
LocationTypeStructure('tu', [
LocationTypeStructure('phi', []),
LocationTypeStructure('dmc', []),
]),
])
]),
LocationTypeStructure('drtb', []),
LocationTypeStructure('cdst', []),
])
])
]
location_structure = [
LocationStructure('CTD', 'ctd', [
LocationStructure('STO', 'sto', [
LocationStructure('CTO', 'cto', [
LocationStructure('DTO', 'dto', [
LocationStructure('TU', 'tu', [
LocationStructure('PHI', 'phi', []),
LocationStructure('DMC', 'dmc', []),
]),
])
]),
LocationStructure('DRTB', 'drtb', []),
LocationStructure('CDST', 'cdst', []),
]),
LocationStructure('STO1', 'sto', [
LocationStructure('CTO1', 'cto', [
LocationStructure('DTO1', 'dto', [
LocationStructure('TU1', 'tu', [
LocationStructure('PHI1', 'phi', []),
LocationStructure('DMC1', 'dmc', []),
]),
])
]),
LocationStructure('DRTB1', 'drtb', []),
LocationStructure('CDST1', 'cdst', []),
])
])
]
location_metadata = {'is_test': 'no', 'nikshay_code': 'nikshay_code'}
setup_location_types_with_structure(self.domain, location_type_structure),
self.locations = setup_locations_with_structure(self.domain, location_structure, location_metadata)
def setUp(self):
domain = bootstrap_domain(TEST_DOMAIN)
loc = make_loc(code="garms",
name="Test RMS",
type="Regional Medical Store",
domain=domain.name)
self.user = bootstrap_user(username='******',
phone_number='323232',
domain=domain.name,
home_loc=loc)
def setUpClass(cls):
super(SMSTests, cls).setUpClass()
cls.backend, cls.backend_mapping = setup_default_sms_test_backend()
cls.domain = util.bootstrap_domain(util.TEST_DOMAIN)
util.bootstrap_location_types(cls.domain.name)
util.bootstrap_products(cls.domain.name)
cls.products = sorted(Product.by_domain(cls.domain.name), key=lambda p: p._id)
cls.loc = util.make_loc('loc1')
cls.sp = cls.loc.linked_supply_point()
cls.users = [util.bootstrap_user(cls, **user_def) for user_def in cls.user_definitions]
def setUpClass(cls):
super(SMSTests, cls).setUpClass()
cls.backend, cls.backend_mapping = setup_default_sms_test_backend()
cls.domain = util.bootstrap_domain(util.TEST_DOMAIN)
util.bootstrap_location_types(cls.domain.name)
util.bootstrap_products(cls.domain.name)
cls.products = sorted(Product.by_domain(cls.domain.name), key=lambda p: p._id)
cls.loc = util.make_loc('loc1')
cls.sp = cls.loc.linked_supply_point()
cls.users = [util.bootstrap_user(cls, **user_def) for user_def in cls.user_definitions]
def setUp(self):
super(SupplyPointDBAccessorsTest, self).setUp()
self.domain = 'supply-point-dbaccessors'
self.project = bootstrap_domain(self.domain)
self.interface = SupplyInterface(self.domain)
self.locations = [
make_loc('1234', name='ben', domain=self.domain),
make_loc('1235', name='ben', domain=self.domain),
make_loc('1236', name='ben', domain=self.domain),
]
def setUp(self):
super(SupplyPointDBAccessorsTest, self).setUp()
self.domain = 'supply-point-dbaccessors'
self.project = bootstrap_domain(self.domain)
self.interface = SupplyInterface(self.domain)
self.locations = [
make_loc('1234', name='ben', domain=self.domain),
make_loc('1235', name='ben', domain=self.domain),
make_loc('1236', name='ben', domain=self.domain),
]
def setUp(self):
self.backend = test.bootstrap(TEST_BACKEND, to_console=True)
self.domain = bootstrap_domain()
self.user = bootstrap_user()
self.verified_number = self.user.get_verified_number()
self.loc = make_loc('loc1')
self.sp = make_supply_point(self.domain.name, self.loc)
self.products = Product.by_domain(self.domain.name)
self.assertEqual(3, len(self.products))
self.spps = {}
for p in self.products:
self.spps[p.code] = make_supply_point_product(self.sp, p._id)
def prepare_domain(domain_name):
from corehq.apps.commtrack.tests.util import bootstrap_domain
domain = bootstrap_domain(domain_name)
previous = None
for name, administrative in [
("MOHSW", True),
("MSDZONE", True),
("REGION", True),
("DISTRICT", True),
("FACILITY", False)
]:
previous, _ = LocationType.objects.get_or_create(
domain=domain_name,
name=name,
parent_type=previous,
administrative=administrative,
)
generator.instantiate_accounting_for_tests()
account = BillingAccount.get_or_create_account_by_domain(
domain.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan_by_domain(
domain, edition=SoftwarePlanEdition.ADVANCED
)
commtrack = domain.commtrack_settings
commtrack.actions.append(
CommtrackActionConfig(action='receipts',
keyword='delivered',
caption='Delivered')
)
commtrack.save()
subscription = Subscription.new_domain_subscription(
account,
domain.name,
plan
)
subscription.is_active = True
subscription.save()
ils_config = ILSGatewayConfig(enabled=True, domain=domain.name, all_stock_data=True)
ils_config.save()
fields_definition = CustomDataFieldsDefinition.get_or_create(domain.name, 'LocationFields')
fields_definition.fields.append(CustomDataField(
slug='group',
label='Group',
is_required=False,
choices=['A', 'B', 'C'],
is_multiple_choice=False
))
fields_definition.save()
return domain
def prepare_domain(domain_name):
from corehq.apps.commtrack.tests.util import bootstrap_domain
domain = bootstrap_domain(domain_name)
previous = None
for name, administrative in [
("MOHSW", True),
("MSDZONE", True),
("REGION", True),
("DISTRICT", True),
("FACILITY", False)
]:
previous, _ = LocationType.objects.get_or_create(
domain=domain_name,
name=name,
parent_type=previous,
administrative=administrative,
)
generator.instantiate_accounting()
account = BillingAccount.get_or_create_account_by_domain(
domain.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.ADVANCED
)
commtrack = domain.commtrack_settings
commtrack.actions.append(
CommtrackActionConfig(action='receipts',
keyword='delivered',
caption='Delivered')
)
commtrack.save()
subscription = Subscription.new_domain_subscription(
account,
domain.name,
plan
)
subscription.is_active = True
subscription.save()
ils_config = ILSGatewayConfig(enabled=True, domain=domain.name, all_stock_data=True)
ils_config.save()
fields_definition = CustomDataFieldsDefinition.get_or_create(domain.name, 'LocationFields')
fields_definition.fields.append(CustomDataField(
slug='group',
label='Group',
is_required=False,
choices=['A', 'B', 'C'],
is_multiple_choice=False
))
fields_definition.save()
return domain
def setUp(self):
self.domain_obj = bootstrap_domain(self.domain)
self.location_types, self.locations = setup_locations_and_types(
self.domain,
self.location_type_names,
self.stock_tracking_types,
self.location_structure,
)
self.suffolk = self.locations['Suffolk']
self.boston = self.locations['Boston']
self.county_type = self.location_types['county']
self.city_type = self.location_types['city']
def setUp(self):
self.domain_obj = bootstrap_domain(self.domain)
self.location_types, self.locations = setup_locations_and_types(
self.domain,
self.location_type_names,
self.stock_tracking_types,
self.location_structure,
)
self.suffolk = self.locations['Suffolk']
self.boston = self.locations['Boston']
self.county_type = self.location_types['county']
self.city_type = self.location_types['city']
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 setUpClass(cls):
super(StockStateTest, cls).setUpClass()
cls.domain_obj = util.bootstrap_domain(cls.domain)
util.bootstrap_location_types(cls.domain)
util.bootstrap_products(cls.domain)
cls.ct_settings = CommtrackConfig.for_domain(cls.domain)
cls.ct_settings.use_auto_consumption = True
cls.ct_settings.consumption_config = ConsumptionConfig(
min_transactions=0,
min_window=0,
optimal_window=60,
min_periods=0,
)
cls.ct_settings.save()
cls.loc = util.make_loc('loc1', domain=cls.domain)
cls.sp = cls.loc.linked_supply_point()
cls.products = sorted(Product.by_domain(cls.domain), key=lambda p: p._id)
def setUp(self):
super(XMLTest, self).setUp()
self.domain = util.bootstrap_domain(util.TEST_DOMAIN)
util.bootstrap_location_types(self.domain.name)
util.bootstrap_products(self.domain.name)
self.products = sorted(Product.by_domain(self.domain.name), key=lambda p: p._id)
self.ct_settings = CommtrackConfig.for_domain(self.domain.name)
self.ct_settings.consumption_config = ConsumptionConfig(
min_transactions=0,
min_window=0,
optimal_window=60,
min_periods=0,
)
self.ct_settings.save()
self.domain = Domain.get(self.domain._id)
self.loc = make_loc('loc1')
self.sp = self.loc.linked_supply_point()
self.users = [util.bootstrap_user(self, **user_def) for user_def in self.user_definitions]
self.user = self.users[0]
def testOTASettings(self):
domain = bootstrap_domain()
ct_settings = CommtrackConfig.for_domain(domain.name)
ct_settings.consumption_config = ConsumptionConfig(
min_transactions=10,
min_window=20,
optimal_window=60,
)
ct_settings.ota_restore_config = StockRestoreConfig(
section_to_consumption_types={'stock': 'consumption'}, )
set_default_monthly_consumption_for_domain(domain.name,
5 * DAYS_IN_MONTH)
restore_settings = ct_settings.get_ota_restore_settings()
self.assertEqual(1, len(restore_settings.section_to_consumption_types))
self.assertEqual(
'consumption',
restore_settings.section_to_consumption_types['stock'])
self.assertEqual(10, restore_settings.consumption_config.min_periods)
self.assertEqual(20, restore_settings.consumption_config.min_window)
self.assertEqual(60, restore_settings.consumption_config.max_window)
self.assertEqual(
150,
restore_settings.consumption_config.
default_monthly_consumption_function('foo', 'bar'))
self.assertFalse(
restore_settings.force_consumption_case_filter(
CommCareCase(type='force-type')))
self.assertEqual(0, len(restore_settings.default_product_list))
ct_settings.ota_restore_config.force_consumption_case_types = [
'force-type'
]
ct_settings.ota_restore_config.use_dynamic_product_list = True
restore_settings = ct_settings.get_ota_restore_settings()
self.assertTrue(
restore_settings.force_consumption_case_filter(
CommCareCase(type='force-type')))
self.assertEqual(3, len(restore_settings.default_product_list))
def setUpClass(cls):
super(StockStateTest, cls).setUpClass()
cls.domain_obj = util.bootstrap_domain(cls.domain)
util.bootstrap_location_types(cls.domain)
util.bootstrap_products(cls.domain)
cls.ct_settings = SQLCommtrackConfig.for_domain(cls.domain)
cls.ct_settings.use_auto_consumption = True
cls.ct_settings.sqlconsumptionconfig = SQLConsumptionConfig(
min_transactions=0,
min_window=0,
optimal_window=60,
)
cls.ct_settings.save()
cls.ct_settings.sqlconsumptionconfig.commtrack_settings = cls.ct_settings
cls.ct_settings.sqlconsumptionconfig.save()
cls.loc = util.make_loc('loc1', domain=cls.domain)
cls.sp = cls.loc.linked_supply_point()
cls.products = sorted(Product.by_domain(cls.domain),
key=lambda p: p._id)
cls.process_ledger_changes = process_pillow_changes(
'LedgerToElasticsearchPillow')
def setUp(self):
self.domain = 'post-api-test'
bootstrap_domain(self.domain)
self.api = MockOpenLMISEndpoint("uri://mock/lmis/endpoint", username='******', password='******')
self.datapath = os.path.join(os.path.dirname(__file__), 'data')
LocationType.objects.get_or_create(domain=self.domain, name='chw')
def setUpClass(cls):
cls.domain = 'test-domain'
cls.domain_obj = bootstrap_domain(cls.domain)
cls.location_types, cls.locations = setup_locations_and_types(
cls.domain, cls.location_type_names, cls.location_structure
)
def setUpClass(cls):
super(FixtureTest, cls).setUpClass()
cls.domain_obj = util.bootstrap_domain(cls.domain)
util.bootstrap_location_types(cls.domain)
util.bootstrap_products(cls.domain)
cls.user = create_restore_user(cls.domain)
def setUp(self):
self.domain = bootstrap_domain(TEST_DOMAIN)
self.loc = make_loc('loc1')
def setUp(self):
self.project = bootstrap_domain(self.domain)
LocationType(domain=self.domain, name='type').save()
def setUpClass(cls):
super(LocationsTest, cls).setUpClass()
delete_all_users()
cls.domain_obj = bootstrap_domain(cls.domain)
bootstrap_location_types(cls.domain)
def setUp(self):
super(SupplyPointTest, self).setUp()
self.domain = bootstrap_domain(TEST_DOMAIN)
self.loc = make_loc('loc1')
def setUpClass(cls):
super(FixtureTest, cls).setUpClass()
cls.domain_obj = util.bootstrap_domain(cls.domain)
util.bootstrap_location_types(cls.domain)
util.bootstrap_products(cls.domain)
cls.user = create_restore_user(cls.domain)
def setUp(self):
self.domain = bootstrap_domain()
LocationType(domain=self.domain.name, name='type').save()
def setUp(self):
self.domain = bootstrap_domain()
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.project = bootstrap_domain(self.domain)
self.products = SQLProduct.objects.filter(domain=self.domain)
LocationType(domain=self.domain, name='type').save()
def setUpClass(cls):
super(ProductsTest, cls).setUpClass()
cls.domain_obj = bootstrap_domain(cls.domain)
def setUpClass(cls):
super(ProductsTest, cls).setUpClass()
cls.domain_obj = bootstrap_domain(cls.domain)
def setUp(self):
self.domain = bootstrap_domain(TEST_DOMAIN)
self.loc = make_loc('loc1')
def setUpClass(cls):
super(BaseTest, cls).setUpClass()
cls.domain_obj = bootstrap_domain(cls.domain)
def setUp(self):
self.domain_obj = bootstrap_domain(self.domain)
self.user = create_restore_user(self.domain, 'user', '123')
self.location_types = setup_location_types_with_structure(self.domain, self.location_type_structure)
self.locations = setup_locations_with_structure(self.domain, self.location_structure)
def setUpClass(cls):
super(TestOperation, cls).setUpClass()
cls.domain_obj = bootstrap_domain(cls.domain)
def setUp(self):
self.domain = bootstrap_domain()
self.products = SQLProduct.objects.filter(domain=self.domain)
def setUp(self):
super(SupplyPointTest, self).setUp()
self.domain = bootstrap_domain(TEST_DOMAIN)
self.loc = make_loc('loc1')
def setUpClass(cls):
super(LocationsTest, cls).setUpClass()
delete_all_users()
cls.domain_obj = bootstrap_domain(cls.domain)
bootstrap_location_types(cls.domain)
def setUpClass(cls):
super(SiteCodeTest, cls).setUpClass()
cls.project = bootstrap_domain(cls.domain)
LocationType(domain=cls.domain, name='type').save()
def setUp(self):
self.domain = bootstrap_domain()
def setUp(self):
self.domain = bootstrap_domain()
LocationType(domain=self.domain.name, name='type').save()
def setUp(self):
self.domain = bootstrap_domain()
self.products = SQLProduct.objects.filter(domain=self.domain)
LocationType(domain=self.domain.name, name='type').save()