def setUpClass(cls):
cls.domain = 'my-domain'
cls.domain_obj = create_domain(cls.domain)
cls.loc1 = make_loc('1', 'loc1', cls.domain)
cls.loc2 = make_loc('2', 'loc2', cls.domain)
cls.loc_ids = [l.location_id for l in [cls.loc1, cls.loc2]]
def testLocationOwner(self):
# This is actually testing several different things, but I figure it's
# worth it, as each of these tests takes a non-trivial amount of time.
non_case_sharing = LocationType.objects.create(
domain=self.domain, name='lt1', shares_cases=False
)
case_sharing = LocationType.objects.create(
domain=self.domain, name='lt2', shares_cases=True
)
location = make_loc('loc-1', 'Loc 1', self.domain, case_sharing)
make_loc('loc-2', 'Loc 2', self.domain, case_sharing)
duplicate_loc = make_loc('loc-3', 'Loc 2', self.domain, case_sharing)
improper_loc = make_loc('loc-4', 'Loc 4', self.domain, non_case_sharing)
res = self.import_mock_file([
['case_id', 'name', 'owner_id', 'owner_name'],
['', 'location-owner-id', location.group_id, ''],
['', 'location-owner-code', '', location.site_code],
['', 'location-owner-name', '', location.name],
['', 'duplicate-location-name', '', duplicate_loc.name],
['', 'non-case-owning-name', '', improper_loc.name],
])
cases = {c.name: c for c in list(get_cases_in_domain(self.domain))}
self.assertEqual(cases['location-owner-id'].owner_id, location.group_id)
self.assertEqual(cases['location-owner-code'].owner_id, location.group_id)
self.assertEqual(cases['location-owner-name'].owner_id, location.group_id)
error_message = ImportErrors.DuplicateLocationName
self.assertIn(error_message, res['errors'])
self.assertEqual(res['errors'][error_message]['rows'], [4])
error_message = ImportErrors.InvalidOwnerId
self.assertIn(error_message, res['errors'])
self.assertEqual(res['errors'][error_message]['rows'], [5])
def setUpClass(cls):
domain = prepare_domain(TEST_DOMAIN)
mohsw = make_loc(code="moh1", name="Test MOHSW 1", type="MOHSW", domain=domain.name)
region = make_loc(code="reg1", name="Test Region 1", type="REGION",
domain=domain.name, parent=mohsw)
district = make_loc(code="dis1", name="Test District 1", type="DISTRICT",
domain=domain.name, parent=region)
facility = make_loc(code="loc1", name="Test Facility 1", type="FACILITY",
domain=domain.name, parent=district)
facility2 = make_loc(code="loc2", name="Test Facility 2", type="FACILITY",
domain=domain.name, parent=district)
test.bootstrap(TEST_BACKEND, to_console=True)
bootstrap_user(facility, username='******', domain=domain.name, home_loc='loc1', phone_number='5551234',
first_name='stella', last_name='Test')
bootstrap_user(facility2, username='******', domain=domain.name, home_loc='loc2', phone_number='5555678',
first_name='bella', last_name='Test')
bootstrap_user(district, username='******', domain=domain.name, home_loc='dis1', phone_number='555',
first_name='trella', last_name='Test')
bootstrap_user(district, username='******', domain=domain.name, phone_number='111',
first_name='MSD', last_name='Person', user_data={'role': 'MSD'})
p = Product(domain=domain.name, name='Jadelle', code='jd', unit='each')
p.save()
p2 = Product(domain=domain.name, name='Mc', code='mc', unit='each')
p2.save()
def test_should_still_save_if_name_changes(self):
# name isn't a dynamic property so should test these still
# get updated alone
parent = make_loc('sillyparents')
parent.location_type = 'village'
parent.save()
existing = make_loc('existingloc', parent=parent)
existing.location_type = 'outlet'
existing.site_code = 'wat'
existing.outlet_type = 'SHG'
existing.save()
data = {
'id': existing._id,
'name': 'newname',
'site_code': 'wat',
'outlet_type': 'SHG',
}
with patch('corehq.apps.locations.forms.LocationForm.save') as save:
result = import_location(self.domain.name, 'outlet', data)
self.assertEqual(save.call_count, 1)
# id isn't accurate because of the mock, but want to make
# sure we didn't actually return with None
self.assertTrue(result['id'] is not None)
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 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 test_setting_existing_list_does_not_submit(self):
user = self.user
user.clear_location_delegates()
loc1 = make_loc('secondloc')
loc2 = make_loc('thirdloc')
user.add_location_delegate(loc1)
user.add_location_delegate(loc2)
with patch('corehq.apps.users.models.CommCareUser.submit_location_block') as submit_blocks:
user.create_location_delegates([loc1, loc2])
self.assertEqual(submit_blocks.call_count, 0)
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 test_full_delete(self):
test_loc = make_loc(
'abernathy_ranch',
type='state',
parent=self.user.location,
domain=self.domain,
)
test_loc.save()
original_count = _count_locations(self.domain)
loc = self.user.sql_location
loc.full_delete()
# it should also delete children
self.assertEqual(
_count_locations(self.domain),
original_count - 2
)
self.assertEqual(
_count_root_locations(self.domain),
0
)
# permanently gone from sql db
self.assertEqual(
len(SQLLocation.objects.all()),
0
)
def test_full_delete(self):
test_loc = make_loc(
'test_loc',
type='state',
parent=self.user.location
)
test_loc.save()
original_count = len(list(Location.by_domain(self.domain.name)))
loc = self.user.location
loc.full_delete()
# it should also delete children
self.assertEqual(
len(list(Location.by_domain(self.domain.name))),
original_count - 2
)
self.assertEqual(
len(Location.root_locations(self.domain.name)),
0
)
# permanently gone from sql db
self.assertEqual(
len(SQLLocation.objects.all()),
0
)
def test_archive(self):
test_state = make_loc(
'pariah',
type='state',
parent=self.user.location,
domain=self.domain,
)
test_state.save()
original_count = _count_locations(self.domain)
loc = self.user.sql_location
loc.archive()
# it should also archive children
self.assertEqual(
_count_locations(self.domain),
original_count - 2
)
self.assertEqual(
_count_root_locations(self.domain),
0
)
loc.unarchive()
# and unarchive children
self.assertEqual(
_count_locations(self.domain),
original_count
)
self.assertEqual(
_count_root_locations(self.domain),
1
)
def test_shouldnt_save_if_no_changes(self):
parent = make_loc("sillyparents")
parent.location_type = "village"
parent.save()
existing = make_loc("existingloc", parent=parent)
existing.location_type = "outlet"
existing.site_code = "wat"
existing.outlet_type = "SHG"
existing.save()
data = {"id": existing._id, "name": existing.name, "site_code": "wat", "outlet_type": "SHG"}
with patch("corehq.apps.locations.forms.LocationForm.save") as save:
result = import_location(self.domain.name, "outlet", data)
self.assertEqual(save.call_count, 0)
self.assertEqual(result["id"], existing._id)
def test_archive(self):
test_state = make_loc(
'teststate',
type='state',
parent=self.user.location
)
test_state.save()
original_count = len(list(Location.by_domain(self.domain.name)))
loc = self.user.location
loc.archive()
# it should also archive children
self.assertEqual(
len(list(Location.by_domain(self.domain.name))),
original_count - 2
)
self.assertEqual(
len(Location.root_locations(self.domain.name)),
0
)
loc.unarchive()
# and unarchive children
self.assertEqual(
len(list(Location.by_domain(self.domain.name))),
original_count
)
self.assertEqual(
len(Location.root_locations(self.domain.name)),
1
)
def test_change_parent(self):
parent = make_loc('originalparent', type='village')
existing = make_loc('existingloc', type='outlet', parent=parent)
new_parent = make_loc('new parent', type='village')
self.assertNotEqual(parent._id, new_parent._id)
data = {
'site_code': existing.site_code,
'name': existing.name,
'outlet_type': 'SHG',
'parent_site_code': new_parent.site_code,
}
result = import_location(self.domain.name, 'outlet', data)
new_loc = Location.get(result['id'])
self.assertEqual(existing._id, new_loc._id)
self.assertEqual(new_loc.parent_id, new_parent._id)
def test_delete_closes_sp_cases(self):
loc = make_loc('test_loc').sql_location
sp = loc.linked_supply_point()
self.assertFalse(sp.closed)
loc.full_delete()
sp = self.accessor.get_supply_point(sp.case_id)
self.assertTrue(sp.closed)
def test_delete_closes_sp_cases(self):
accessor = SupplyInterface(self.domain)
loc = make_loc('ghost_nation', domain=self.domain).sql_location
sp = loc.linked_supply_point()
self.assertFalse(sp.closed)
loc.full_delete()
sp = accessor.get_supply_point(sp.case_id)
self.assertTrue(sp.closed)
def test_can_set_locations(self):
user = self.user
loc1 = make_loc('secondloc')
sp1 = make_supply_point(self.domain.name, loc1)
loc2 = make_loc('thirdloc')
sp2 = make_supply_point(self.domain.name, loc2)
user.set_locations([loc1, loc2])
# should only have the two new cases
self.assertEqual(len(user.locations), 2)
# and will have access to these two
self.check_supply_point(user, sp1._id)
self.check_supply_point(user, sp2._id)
def test_can_set_sql_locations(self):
user = self.user
loc1 = make_loc('secondloc').sql_location
sp1 = loc1.linked_supply_point()
loc2 = make_loc('thirdloc').sql_location
sp2 = loc2.linked_supply_point()
user.create_location_delegates([loc1, loc2])
# should only have the two new cases
self.assertEqual(len(user.locations), 2)
# and will have access to these two
self.check_supply_point(user, sp1.case_id)
self.check_supply_point(user, sp2.case_id)
def test_can_set_locations(self):
user = self.user
loc1 = make_loc('secondloc')
sp1 = loc1.linked_supply_point()
loc2 = make_loc('thirdloc')
sp2 = loc2.linked_supply_point()
user.create_location_delegates([loc1, loc2])
# should only have the two new cases
self.assertEqual(len(user.locations), 2)
# and will have access to these two
self.check_supply_point(user, sp1.case_id)
self.check_supply_point(user, sp2.case_id)
def test_setting_existing_list_does_not_submit(self):
user = self.user
user.clear_locations()
loc1 = make_loc('secondloc')
make_supply_point(self.domain.name, loc1)
loc2 = make_loc('thirdloc')
make_supply_point(self.domain.name, loc2)
user.add_location(loc1)
user.add_location(loc2)
with patch('corehq.apps.commtrack.models.CommTrackUser.submit_location_block') as submit_blocks:
user.set_locations([loc1, loc2])
self.assertEqual(submit_blocks.call_count, 0)
def test_updating_existing_location_properties(self):
parent = make_loc("sillyparents")
parent.location_type = "village"
parent.save()
existing = make_loc("existingloc", parent=parent)
existing.location_type = "outlet"
existing.save()
data = {"id": existing._id, "name": existing.name, "site_code": "wat", "outlet_type": "SHG"}
self.assertNotEqual(existing.site_code, data["site_code"])
loc_id = import_location(self.domain.name, "outlet", data).get("id", None)
new_loc = Location.get(loc_id)
self.assertEqual(existing._id, loc_id)
self.assertEqual(new_loc.site_code, data["site_code"])
def test_delete_closes_sp_cases(self):
loc = make_loc('test_loc').sql_location
sp = loc.linked_supply_point()
self.assertFalse(sp.closed)
loc.full_delete()
sp = self.accessor.get_supply_point(sp.case_id)
self.assertTrue(sp.closed)
def test_setting_existing_list_does_not_submit(self):
user = self.user
user.clear_locations()
loc1 = make_loc('secondloc')
make_supply_point(self.domain.name, loc1)
loc2 = make_loc('thirdloc')
make_supply_point(self.domain.name, loc2)
user.add_location(loc1)
user.add_location(loc2)
with patch('corehq.apps.commtrack.models.CommTrackUser.submit_location_block') as submit_blocks:
user.set_locations([loc1, loc2])
self.assertEqual(submit_blocks.call_count, 0)
def test_change_parent(self):
parent = make_loc('originalparent', type='village')
existing = make_loc('existingloc', type='outlet', parent=parent)
new_parent = make_loc('new parent', type='village')
self.assertNotEqual(parent._id, new_parent._id)
data = {
'site_code': existing.site_code,
'name': existing.name,
'outlet_type': 'SHG',
'parent_site_code': new_parent.site_code,
}
result = import_location(self.domain.name, 'outlet', data)
new_loc = Location.get(result['id'])
self.assertEqual(existing._id, new_loc._id)
self.assertEqual(new_loc.parent_id, new_parent._id)
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 test_can_set_locations(self):
user = self.user
loc1 = make_loc('secondloc')
sp1 = make_supply_point(self.domain.name, loc1)
loc2 = make_loc('thirdloc')
sp2 = make_supply_point(self.domain.name, loc2)
user.create_location_delegates([loc1, loc2])
# should only have the two new cases
self.assertEqual(len(user.locations), 2)
# and will have access to these two
self.check_supply_point(user, sp1._id)
self.check_supply_point(user, sp2._id)
def test_delete_closes_sp_cases(self):
accessor = SupplyInterface(self.domain)
loc = make_loc('ghost_nation', domain=self.domain).sql_location
sp = loc.linked_supply_point()
self.assertFalse(sp.closed)
loc.full_delete()
sp = accessor.get_supply_point(sp.case_id)
self.assertTrue(sp.closed)
def test_delete_closes_sp_cases(self):
loc = make_loc('test_loc')
sp = loc.linked_supply_point()
self.assertFalse(sp.closed)
loc.full_delete()
sp = SupplyPointCase.get(sp.case_id)
self.assertTrue(sp.closed)
def testLocationOwner(self):
# This is actually testing several different things, but I figure it's
# worth it, as each of these tests takes a non-trivial amount of time.
non_case_sharing = LocationType.objects.create(domain=self.domain,
name='lt1',
shares_cases=False)
case_sharing = LocationType.objects.create(domain=self.domain,
name='lt2',
shares_cases=True)
location = make_loc('loc-1', 'Loc 1', self.domain, case_sharing.code)
make_loc('loc-2', 'Loc 2', self.domain, case_sharing.code)
duplicate_loc = make_loc('loc-3', 'Loc 2', self.domain,
case_sharing.code)
improper_loc = make_loc('loc-4', 'Loc 4', self.domain,
non_case_sharing.code)
res = self.import_mock_file([
['case_id', 'name', 'owner_id', 'owner_name'],
['', 'location-owner-id', location.group_id, ''],
['', 'location-owner-code', '', location.site_code],
['', 'location-owner-name', '', location.name],
['', 'duplicate-location-name', '', duplicate_loc.name],
['', 'non-case-owning-name', '', improper_loc.name],
])
case_ids = self.accessor.get_case_ids_in_domain()
cases = {c.name: c for c in list(self.accessor.get_cases(case_ids))}
self.assertEqual(cases['location-owner-id'].owner_id,
location.group_id)
self.assertEqual(cases['location-owner-code'].owner_id,
location.group_id)
self.assertEqual(cases['location-owner-name'].owner_id,
location.group_id)
error_message = exceptions.DuplicateLocationName.title
error_column_name = None
self.assertIn(error_message, res['errors'])
self.assertEqual(
res['errors'][error_message][error_column_name]['rows'], [5])
error_message = exceptions.InvalidOwner.title
self.assertIn(error_message, res['errors'])
error_column_name = 'owner_name'
self.assertEqual(
res['errors'][error_message][error_column_name]['rows'], [6])
def test_shouldnt_save_if_no_changes(self):
parent = make_loc('sillyparents', type='village')
existing = make_loc('existingloc', type='outlet', parent=parent)
existing.site_code = 'wat'
existing.outlet_type = 'SHG'
existing.save()
data = {
'id': existing._id,
'name': existing.name,
'site_code': 'wat',
'outlet_type': 'SHG',
}
with patch('corehq.apps.locations.forms.LocationForm.save') as save:
result = import_location(self.domain.name, 'outlet', data)
self.assertEqual(save.call_count, 0)
self.assertEqual(result['id'], existing._id)
def test_sync(self):
test_state = make_loc('teststate',
type='state',
parent=self.user.location)
test_village = make_loc('testvillage',
type='village',
parent=test_state)
try:
sql_village = SQLLocation.objects.get(
name='testvillage',
domain=self.domain.name,
)
self.assertEqual(sql_village.name, test_village.name)
self.assertEqual(sql_village.domain, test_village.domain)
except SQLLocation.DoesNotExist:
self.fail("Synced SQL object does not exist")
def test_change_to_invalid_parent(self):
parent = make_loc('original parent', type='village')
existing = make_loc('existingloc1', type='outlet', parent=parent)
new_parent = make_loc('new parent', type='state')
data = {
'site_code': existing.site_code,
'name': existing.name,
'outlet_type': 'SHG',
'parent_site_code': new_parent.site_code,
}
result = import_location(self.domain.name, 'outlet', data)
self.assertEqual(None, result['id'])
self.assertTrue('Invalid parent type' in result['message'])
new_loc = Location.get(existing._id)
self.assertEqual(existing._id, new_loc._id)
self.assertEqual(new_loc.parent_id, parent._id)
def test_location_removal_only_submits_if_it_existed(self):
user = self.user
# can't test with the original since the user already owns it
loc = make_loc('secondloc')
with patch('corehq.apps.users.models.CommCareUser.submit_location_block') as submit_blocks:
user.remove_location_delegate(loc)
self.assertEqual(submit_blocks.call_count, 0)
def test_change_to_invalid_parent(self):
parent = make_loc('original parent', type='village')
existing = make_loc('existingloc1', type='outlet', parent=parent)
new_parent = make_loc('new parent', type='state')
data = {
'site_code': existing.site_code,
'name': existing.name,
'outlet_type': 'SHG',
'parent_site_code': new_parent.site_code,
}
result = import_location(self.domain.name, 'outlet', data)
self.assertEqual(None, result['id'])
self.assertTrue('Invalid parent type' in result['message'])
new_loc = Location.get(existing._id)
self.assertEqual(existing._id, new_loc._id)
self.assertEqual(new_loc.parent_id, parent._id)
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(LocationsTest, self).setUp()
self.user = CommCareUser.create(domain=self.domain,
username='******',
password='******',
created_by=None,
created_via=None)
self.loc = make_loc('mariposa_saloon', domain=self.domain)
self.user.set_location(self.loc)
def test_shouldnt_save_if_no_changes(self):
parent = make_loc('sillyparents', type='village')
existing = make_loc('existingloc', type='outlet', parent=parent)
existing.site_code = 'wat'
existing.outlet_type = 'SHG'
existing.save()
data = {
'id': existing._id,
'name': existing.name,
'site_code': 'wat',
'outlet_type': 'SHG',
}
with patch('corehq.apps.locations.forms.LocationForm.save') as save:
result = import_location(self.domain.name, 'outlet', data)
self.assertEqual(save.call_count, 0)
self.assertEqual(result['id'], existing._id)
def test_updating_existing_location_properties(self):
parent = make_loc('sillyparents', type='village')
existing = make_loc('existingloc', type='outlet', parent=parent)
data = {
'id': existing._id,
'name': existing.name,
'site_code': 'wat',
'outlet_type': 'SHG'
}
self.assertNotEqual(existing.site_code, data['site_code'])
loc_id = import_location(self.domain.name, 'outlet', data).get('id', None)
new_loc = Location.get(loc_id)
self.assertEqual(existing._id, loc_id)
self.assertEqual(new_loc.site_code, data['site_code'])
def test_commtrack_user_has_multiple_locations(self):
user = self.user
loc = make_loc('secondloc')
sp = make_supply_point(self.domain.name, loc)
user.add_location(loc)
self.check_supply_point(user, sp._id)
self.assertTrue(len(user.locations), 2)
self.assertEqual(user.locations[1].name, 'secondloc')
def test_commtrack_user_has_multiple_locations(self):
user = self.user
loc = make_loc('secondloc')
sp = loc.linked_supply_point()
user.add_location_delegate(loc)
self.check_supply_point(user, sp.case_id)
self.assertTrue(len(user.locations), 2)
self.assertEqual(user.locations[1].name, 'secondloc')
def test_location_removal_only_submits_if_it_existed(self):
user = self.user
# can't test with the original since the user already owns it
loc = make_loc('secondloc')
make_supply_point(self.domain.name, loc)
with patch('corehq.apps.commtrack.models.CommTrackUser.submit_location_block') as submit_blocks:
user.remove_location(loc)
self.assertEqual(submit_blocks.call_count, 0)
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 test_location_removal_only_submits_if_it_existed(self):
user = self.user
# can't test with the original since the user already owns it
loc = make_loc('secondloc')
make_supply_point(self.domain.name, loc)
with patch('corehq.apps.commtrack.models.CommTrackUser.submit_location_block') as submit_blocks:
user.remove_location(loc)
self.assertEqual(submit_blocks.call_count, 0)
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 test_updating_existing_location_properties(self):
parent = make_loc('sillyparents', type='village')
existing = make_loc('existingloc', type='outlet', parent=parent)
data = {
'id': existing._id,
'name': existing.name,
'site_code': 'wat',
'outlet_type': 'SHG'
}
self.assertNotEqual(existing.site_code, data['site_code'])
loc_id = import_location(self.domain.name, 'outlet',
data).get('id', None)
new_loc = Location.get(loc_id)
self.assertEqual(existing._id, loc_id)
self.assertEqual(new_loc.site_code, data['site_code'])
def test_commtrack_user_has_multiple_locations(self):
user = self.user
loc = make_loc('secondloc')
sp = make_supply_point(self.domain.name, loc)
user.add_location_delegate(loc)
self.check_supply_point(user, sp._id)
self.assertTrue(len(user.locations), 2)
self.assertEqual(user.locations[1].name, 'secondloc')
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 test_location_removal_only_submits_if_it_existed(self):
user = self.user
# can't test with the original since the user already owns it
loc = make_loc('secondloc')
with patch(
'corehq.apps.users.models.CommCareUser.submit_location_block'
) as submit_blocks:
user.remove_location_delegate(loc)
self.assertEqual(submit_blocks.call_count, 0)
def test_archive_flips_sp_cases(self):
loc = make_loc('las_mudas', domain=self.domain).sql_location
sp = loc.linked_supply_point()
self.assertFalse(sp.closed)
loc.archive()
sp = loc.linked_supply_point()
self.assertTrue(sp.closed)
loc.unarchive()
sp = loc.linked_supply_point()
self.assertFalse(sp.closed)
def test_archive_flips_sp_cases(self):
loc = make_loc('someloc').sql_location
sp = loc.linked_supply_point()
self.assertFalse(sp.closed)
loc.archive()
sp = loc.linked_supply_point()
self.assertTrue(sp.closed)
loc.unarchive()
sp = loc.linked_supply_point()
self.assertFalse(sp.closed)
def test_archive_flips_sp_cases(self):
loc = make_loc('someloc')
sp = make_supply_point(self.domain.name, loc)
self.assertFalse(sp.closed)
loc.archive()
sp = SupplyPointCase.get(sp._id)
self.assertTrue(sp.closed)
loc.unarchive()
sp = SupplyPointCase.get(sp._id)
self.assertFalse(sp.closed)
def setUpClass(cls):
domain = prepare_domain(TEST_DOMAIN)
p = Product(domain=domain.name, name='Jadelle', code='jd', unit='each')
p.save()
p2 = Product(domain=domain.name,
name='Male Condom',
code='mc',
unit='each')
p2.save()
p3 = Product(domain=domain.name, name='Lofem', code='lf', unit='each')
p3.save()
p4 = Product(domain=domain.name, name='Ng', code='ng', unit='each')
p4.save()
p5 = Product(domain=domain.name,
name='Micro-G',
code='mg',
unit='each')
p5.save()
loc = make_loc(code="garms",
name="Test RMS",
type="Regional Medical Store",
domain=domain.name)
test.bootstrap(TEST_BACKEND, to_console=True)
cls.user1 = bootstrap_user(username='******',
first_name='test1',
last_name='test1',
domain=domain.name,
home_loc=loc)
cls.user2 = bootstrap_user(username='******',
domain=domain.name,
home_loc=loc,
first_name='test2',
last_name='test2',
phone_number='222222',
user_data={'role': 'In Charge'})
try:
XFormInstance.get(docid='test-xform')
except ResourceNotFound:
xform = XFormInstance(_id='test-xform')
xform.save()
sql_location = loc.sql_location
sql_location.products = SQLProduct.objects.filter(product_id=p5.get_id)
sql_location.save()
config = CommtrackConfig.for_domain(domain.name)
config.actions.append(
CommtrackActionConfig(action='receipts',
keyword='rec',
caption='receipts'))
config.consumption_config = ConsumptionConfig(min_transactions=0,
min_window=0,
optimal_window=60)
config.save()
def test_given_id_matches_type(self):
existing = make_loc('existingloc', type='state')
data = {
'site_code': existing.site_code,
'name': 'new_name',
}
result = import_location(self.domain.name, 'outlet', data)
self.assertEqual(result['id'], None)
self.assertTrue('Existing location type error' in result['message'])
def setUpClass(cls):
super(TestReminders, cls).setUpClass()
cls.sms_backend, cls.sms_backend_mapping = setup_default_sms_test_backend()
domain = prepare_domain(TEST_DOMAIN)
mohsw = make_loc(code="moh1", name="Test MOHSW 1", type="MOHSW", domain=domain.name)
msdzone = make_loc(code="msd1", name="MSD Zone 1", type="MSDZONE",
domain=domain.name, parent=mohsw)
region = make_loc(code="reg1", name="Test Region 1", type="REGION",
domain=domain.name, parent=msdzone)
cls.district = make_loc(code="dis1", name="Test District 1", type="DISTRICT",
domain=domain.name, parent=region)
cls.facility = make_loc(code="loc1", name="Test Facility 1", type="FACILITY",
domain=domain.name, parent=cls.district)
cls.facility.metadata['group'] = 'B'
cls.facility2 = make_loc(code="loc2", name="Test Facility 2", type="FACILITY",
domain=domain.name, parent=cls.district)
cls.facility2.metadata['group'] = 'C'
cls.facility.save()
cls.facility2.save()
cls.user1 = bootstrap_user(
cls.facility, username='******', domain=domain.name, home_loc='loc1', phone_number='5551234',
first_name='test', last_name='Test'
)
bootstrap_user(cls.facility2, username='******', domain=domain.name, home_loc='loc2',
phone_number='5555678', first_name='test1', last_name='Test')
bootstrap_user(cls.district, username='******', domain=domain.name, home_loc='dis1', phone_number='555',
first_name='test1', last_name='Test')
bootstrap_user(cls.district, username='******', domain=domain.name, phone_number='111',
first_name='MSD', last_name='Person', user_data={'role': 'MSD'})
def test_should_still_save_if_name_changes(self):
# name isn't a dynamic property so should test these still
# get updated alone
parent = make_loc('sillyparents', type='village')
existing = make_loc('existingloc', type='outlet', parent=parent)
existing.site_code = 'wat'
existing.outlet_type = 'SHG'
existing.save()
data = {
'id': existing._id,
'name': 'newname',
'site_code': 'wat',
'outlet_type': 'SHG',
}
with patch('corehq.apps.locations.forms.LocationForm.save') as save:
result = import_location(self.domain.name, 'outlet', data)
self.assertEqual(save.call_count, 1)
# id isn't accurate because of the mock, but want to make
# sure we didn't actually return with None
self.assertTrue(result['id'] is not None)
def test_setting_new_list_causes_submit(self):
"""
this test mostly exists to make sure the one
testing no submits doesn't silently stop actually working
"""
user = self.user
loc1 = make_loc('secondloc')
make_supply_point(self.domain.name, loc1)
with patch('corehq.apps.commtrack.models.CommTrackUser.submit_location_block') as submit_blocks:
user.set_locations([loc1])
self.assertEqual(submit_blocks.call_count, 1)
def test_id_of_invalid_parent_type(self):
# state can't have outlet as child
parent = make_loc('sillyparents', type='state')
data = {'name': 'oops', 'outlet_type': 'SHG', 'parent_id': parent._id}
original_count = len(list(Location.by_domain(self.domain.name)))
result = import_location(self.domain.name, 'outlet', data)
self.assertEqual(result['id'], None)
self.assertEqual(len(list(Location.by_domain(self.domain.name))),
original_count)
self.assertTrue('Invalid parent type' in result['message'])
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 test_import_with_existing_parent_by_id(self):
# state can't have outlet as child
parent = make_loc('sillyparents', type='state')
data = {'name': 'importedloc', 'parent_id': parent._id}
result = import_location(self.domain.name, 'district', data)
if result['id'] is None:
self.fail('import failed with error: %s' % result['message'])
self.assertTrue(data['name'] in self.names_of_locs())
new_loc = Location.get(result['id'])
self.assertEqual(new_loc.parent_id, parent._id)
def test_setting_new_list_causes_submit(self):
"""
this test mostly exists to make sure the one
testing no submits doesn't silently stop actually working
"""
user = self.user
loc1 = make_loc('secondloc')
with patch(
'corehq.apps.users.models.CommCareUser.submit_location_block'
) as submit_blocks:
user.create_location_delegates([loc1])
self.assertEqual(submit_blocks.call_count, 1)
