def setUp(self):
super(CommTrackTest, self).setUp()
# might as well clean house before doing anything
delete_all_xforms()
delete_all_cases()
delete_all_sync_logs()
StockReport.objects.all().delete()
StockTransaction.objects.all().delete()
self.backend, self.backend_mapping = setup_default_sms_test_backend()
self.domain = bootstrap_domain(TEST_DOMAIN)
bootstrap_location_types(self.domain.name)
bootstrap_products(self.domain.name)
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,
)
# todo: remove?
if self.requisitions_enabled:
self.ct_settings.requisition_config = get_default_requisition_config(
)
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 = [
bootstrap_user(self, **user_def)
for user_def in self.user_definitions
]
# everyone should be in a group.
self.group = Group(domain=TEST_DOMAIN,
name='commtrack-folks',
users=[u._id for u in self.users],
case_sharing=True)
self.group._id = self.sp.owner_id
self.group.save()
self.products = sorted(Product.by_domain(self.domain.name),
key=lambda p: p._id)
self.assertEqual(3, len(self.products))
def setUpClass(cls):
super(SchedulingRecipientTest, cls).setUpClass()
cls.domain_obj = create_domain(cls.domain)
cls.location_types = setup_location_types(cls.domain, ['country', 'state', 'city'])
cls.state_location = make_loc('ma', domain=cls.domain, type='state')
cls.city_location = make_loc('boston', domain=cls.domain, type='city', parent=cls.state_location)
cls.mobile_user = CommCareUser.create(cls.domain, 'mobile', 'abc')
cls.mobile_user.set_location(cls.city_location)
cls.web_user = WebUser.create(cls.domain, 'web', 'abc')
cls.group = Group(domain=cls.domain, users=[cls.mobile_user.get_id])
cls.group.save()
def testUserAddedToGroup(self):
# 4. If the case has an owner that is a group, and the user is not in the group,
# add the user to the group and the leave the owner untouched.
group = Group(
domain=self.domain,
name='reconciliation test group',
users=[self.other_user._id],
case_sharing=True,
)
group.save()
case = self._make_case(self.other_user._id, group._id)
self.assertEqual(group._id, case.owner_id)
reconcile_ownership(case, self.user)
case = CommCareCase.get(case._id)
self.assertEqual(group._id, case.owner_id)
group = Group.get(group._id)
self.assertTrue(self.user._id in group.users)
def test_groups_to_user_reindexer(self):
initialize_index_and_mapping(self.es, USER_INDEX_INFO)
user_id = uuid.uuid4().hex
domain = 'test-groups-to-user-reindex'
_create_es_user(self.es, user_id, domain)
# create and save a group
group = Group(domain=domain, name='g1', users=[user_id])
group.save()
call_command('ptop_reindexer_v2', **{
'index': 'groups-to-user',
'noinput': True
})
self.es.indices.refresh(USER_INDEX)
_assert_es_user_and_groups(self, self.es, user_id, [group._id],
[group.name])
def setUpClass(cls):
super(TemplatingTestCase, cls).setUpClass()
cls.domain = 'templating-test'
cls.domain_obj = Domain(name=cls.domain)
cls.domain_obj.save()
cls.mobile_user = CommCareUser.create(
cls.domain,
'mobile1@templating-test',
'12345',
None,
None,
first_name='Mobile',
last_name='User'
)
cls.mobile_user.add_phone_number('999123')
cls.mobile_user.save()
cls.web_user = WebUser.create(
cls.domain,
'web1@templating-test',
'12345',
created_by=None,
created_via=None,
first_name='Web',
last_name='User'
)
cls.web_user.add_phone_number('999456')
cls.web_user.save()
cls.group = Group(domain=cls.domain, name='Test Group')
cls.group.save()
cls.location_type = LocationType.objects.create(
domain=cls.domain,
name='top-level',
code='top-level'
)
cls.location = SQLLocation.objects.create(
domain=cls.domain,
name='Test Location',
site_code='loc1234',
location_type=cls.location_type
)
def test_update(self):
user = CommCareUser.create(domain=self.domain.name,
username="******",
password="******",
created_by=None,
created_via=None)
group = Group({"name": "test"})
group.save()
self.addCleanup(user.delete, deleted_by=None)
self.addCleanup(group.delete)
user_json = {
"first_name": "test",
"last_name": "last",
"email": "*****@*****.**",
"language": "pol",
"phone_numbers": ["+50253311399", "50253314588"],
"groups": [group._id],
"user_data": {
PROFILE_SLUG: self.profile.id,
"chw_id": "13/43/DFA"
}
}
backend_id = user._id
response = self._assert_auth_post_resource(
self.single_endpoint(backend_id),
json.dumps(user_json),
content_type='application/json',
method='PUT')
self.assertEqual(response.status_code, 200, response.content)
self.assertEqual(1, len(CommCareUser.by_domain(self.domain.name)))
modified = CommCareUser.get(backend_id)
self.assertEqual(modified.username, "test")
self.assertEqual(modified.first_name, "test")
self.assertEqual(modified.last_name, "last")
self.assertEqual(modified.email, "*****@*****.**")
self.assertEqual(modified.language, "pol")
self.assertEqual(modified.get_group_ids()[0], group._id)
self.assertEqual(modified.metadata["chw_id"], "13/43/DFA")
self.assertEqual(modified.metadata[PROFILE_SLUG], self.profile.id)
self.assertEqual(modified.metadata["imaginary"], "yes")
self.assertEqual(modified.default_phone_number, "50253311399")
def test_owned_by_group(self):
ids = []
for i in range(5):
user = CommCareUser.create(self.domain, 'owned-group-test-user-%s' % i, 'password', None, None)
user.save()
self.addCleanup(user.delete, deleted_by=None)
ids.append(user._id)
group = Group(domain=self.domain, name='owned-group-test-group', users=ids)
group.save()
self.addCleanup(group.delete)
owners = get_owning_users(group._id)
self.assertEqual(5, len(owners))
ids_back = []
for o in owners:
self.assertTrue(isinstance(o, CommCareUser))
ids_back.append(o._id)
self.assertEqual(set(ids), set(ids_back))
def test_remove_user(self):
group1 = Group(
domain=DOMAIN,
name='group1',
users=[self.active_user._id, self.inactive_user._id, self.deleted_user._id]
)
group1.save()
self.assertTrue(group1.remove_user(self.active_user._id))
group1.save()
group1 = Group.get(group1._id)
self.assertIn(self.active_user._id, group1.removed_users)
self.assertNotIn(self.active_user._id, group1.users)
group1.add_user(self.active_user._id)
group1 = Group.get(group1._id)
self.assertNotIn(self.active_user._id, group1.removed_users)
self.assertIn(self.active_user._id, group1.users)
def setUp(self):
super(CommTrackSyncTest, self).setUp()
self.group = Group(domain=util.TEST_DOMAIN, name='commtrack-folks',
users=[self.user._id], case_sharing=True)
self.group._id = self.sp.owner_id
self.group.save()
self.restore_user = self.user.to_ota_restore_user()
self.sp_block = CaseBlock(
case_id=self.sp.case_id,
).as_xml()
# get initial restore token
restore_config = RestoreConfig(
project=self.domain,
restore_user=self.restore_user,
params=RestoreParams(version=V2),
)
self.sync_log_id = synclog_id_from_restore_payload(restore_config.get_payload().as_string())
def test_create(self):
group = Group({"name": "test"})
group.save()
self.addCleanup(group.delete)
self.assertEqual(0, len(CommCareUser.by_domain(self.domain.name)))
user_json = {
"username": "******",
"password": "******",
"first_name": "John",
"last_name": "Doe",
"email": "*****@*****.**",
"language": "en",
"phone_numbers": [
"+50253311399",
"50253314588"
],
"groups": [
group._id
],
"user_data": {
"chw_id": "13/43/DFA"
}
}
response = self._assert_auth_post_resource(self.list_endpoint,
json.dumps(user_json),
content_type='application/json')
self.assertEqual(response.status_code, 201)
[user_back] = CommCareUser.by_domain(self.domain.name)
self.addCleanup(user_back.delete, deleted_by=None)
self.addCleanup(lambda: send_to_elasticsearch('users', user_back.to_json(), delete=True))
self.assertEqual(user_back.username, "jdoe")
self.assertEqual(user_back.first_name, "John")
self.assertEqual(user_back.last_name, "Doe")
self.assertEqual(user_back.email, "*****@*****.**")
self.assertEqual(user_back.language, "en")
self.assertEqual(user_back.get_group_ids()[0], group._id)
self.assertEqual(user_back.user_data["chw_id"], "13/43/DFA")
self.assertEqual(user_back.default_phone_number, "50253311399")
def testGetUsers(self):
domain = 'group-test'
active_user = CommCareUser.create(domain=domain,
username='******',
password='******')
inactive_user = CommCareUser.create(domain=domain,
username='******',
password='******')
inactive_user.is_active = False
inactive_user.save()
deleted_user = CommCareUser.create(domain=domain,
username='******',
password='******')
deleted_user.retire()
group = Group(
domain=domain,
name='group',
users=[active_user._id, inactive_user._id, deleted_user._id])
group.save()
def _check_active_users(userlist):
self.assertEqual(len(userlist), 1)
self.assertEqual(active_user._id, userlist[0])
# try all the flavors of this
_check_active_users([u._id for u in group.get_users()])
_check_active_users(group.get_user_ids())
_check_active_users([u._id for u in group.get_static_users()])
_check_active_users(group.get_static_user_ids())
def _check_all_users(userlist):
self.assertEqual(len(userlist), 2)
self.assertTrue(active_user._id in userlist)
self.assertTrue(inactive_user._id in userlist)
self.assertFalse(deleted_user._id in userlist)
_check_all_users([u._id for u in group.get_users(is_active=False)])
_check_all_users(group.get_user_ids(is_active=False))
_check_all_users(
[u._id for u in group.get_static_users(is_active=False)])
_check_all_users(group.get_static_user_ids(is_active=False))
def add_group(request, domain):
group_name = request.POST['group_name']
if not group_name:
messages.error(
request,
_("We could not create the group; "
"please give it a name first"))
return HttpResponseRedirect(request.META['HTTP_REFERER'])
group = Group.by_name(domain, group_name)
if group:
messages.warning(
request,
_("A group with this name already exists: instead of making "
"a new one, we've brought you to the existing one."))
else:
group = Group(name=group_name, domain=domain)
group.save()
return HttpResponseRedirect(
reverse("group_members", args=(domain, group.get_id)))
def setUpClass(cls):
with trap_extra_setup(ConnectionError,
msg="cannot connect to elasicsearch"):
es = get_es_new()
cls.tearDownClass()
initialize_index_and_mapping(es, CASE_INDEX_INFO)
initialize_index_and_mapping(es, GROUP_INDEX_INFO)
initialize_index_and_mapping(es, XFORM_INDEX_INFO)
case = new_case(closed=True)
send_to_elasticsearch('cases', case.to_json())
case = new_case(closed=False)
send_to_elasticsearch('cases', case.to_json())
case = new_case(closed=True, owner_id="foo")
send_to_elasticsearch('cases', case.to_json())
case = new_case(closed=False, owner_id="bar")
send_to_elasticsearch('cases', case.to_json())
group = Group(_id=uuid.uuid4().hex, users=["foo", "bar"])
cls.group_id = group._id
send_to_elasticsearch('groups', group.to_json())
form = new_form(form={"meta": {"userID": None}})
send_to_elasticsearch('forms', form.to_json())
form = new_form(form={"meta": {"userID": ""}})
send_to_elasticsearch('forms', form.to_json())
form = new_form(form={"meta": {"deviceID": "abc"}})
send_to_elasticsearch('forms', form.to_json())
form = new_form(form={"meta": {"userID": uuid.uuid4().hex}})
send_to_elasticsearch('forms', form.to_json())
es.indices.refresh(CASE_INDEX_INFO.index)
es.indices.refresh(XFORM_INDEX_INFO.index)
es.indices.refresh(GROUP_INDEX_INFO.index)
def test_create(self):
self.client.login(username=self.username, password=self.password)
group = Group({"name": "test"})
group.save()
self.assertEqual(0, len(CommCareUser.by_domain(self.domain.name)))
user_json = {
"username": "******",
"password": "******",
"first_name": "John",
"last_name": "Doe",
"email": "*****@*****.**",
"language": "en",
"phone_numbers": [
"+50253311399",
"50253314588"
],
"groups": [
group._id
],
"user_data": {
"chw_id": "13/43/DFA"
}
}
response = self.client.post(self.list_endpoint,
simplejson.dumps(user_json),
content_type='application/json')
self.assertEqual(response.status_code, 201)
[user_back] = CommCareUser.by_domain(self.domain.name)
self.assertEqual(user_back.username, "jdoe")
self.assertEqual(user_back.first_name, "John")
self.assertEqual(user_back.last_name, "Doe")
self.assertEqual(user_back.email, "*****@*****.**")
self.assertEqual(user_back.language, "en")
self.assertEqual(user_back.get_group_ids()[0], group._id)
self.assertEqual(user_back.user_data["chw_id"], "13/43/DFA")
self.assertEqual(user_back.default_phone_number, "+50253311399")
user_back.delete()
group.delete()
def test_update(self):
self.client.login(username=self.username, password=self.password)
user = CommCareUser.create(domain=self.domain.name, username="******", password="******")
group = Group({"name": "test"})
group.save()
user_json = {
"first_name": "test",
"last_name": "last",
"email": "*****@*****.**",
"language": "pol",
"phone_numbers": [
"+50253311399",
"50253314588"
],
"groups": [
group._id
],
"user_data": {
"chw_id": "13/43/DFA"
}
}
backend_id = user._id
response = self.client.put(self.single_endpoint(backend_id),
simplejson.dumps(user_json),
content_type='application/json')
self.assertEqual(response.status_code, 202, response.content)
self.assertEqual(1, len(CommCareUser.by_domain(self.domain.name)))
modified = CommCareUser.get(backend_id)
self.assertEqual(modified.username, "test")
self.assertEqual(modified.first_name, "test")
self.assertEqual(modified.last_name, "last")
self.assertEqual(modified.email, "*****@*****.**")
self.assertEqual(modified.language, "pol")
self.assertEqual(modified.get_group_ids()[0], group._id)
self.assertEqual(modified.user_data["chw_id"], "13/43/DFA")
self.assertEqual(modified.default_phone_number, "+50253311399")
modified.delete()
group.delete()
def test_pillow(self):
user_id = uuid.uuid4().hex
domain = 'dbtest-group-user'
_create_es_user(self.es_client, user_id, domain)
_assert_es_user_and_groups(self, self.es_client, user_id, None, None)
# create and save a group
group = Group(domain=domain, name='g1', users=[user_id])
group.save()
# send to kafka
since = get_topic_offset(topics.GROUP)
producer.send_change(topics.GROUP, _group_to_change_meta(group.to_json()))
# process using pillow
pillow = get_group_pillow()
pillow.process_changes(since=since, forever=False)
# confirm updated in elasticsearch
self.es_client.indices.refresh(USER_INDEX)
_assert_es_user_and_groups(self, self.es_client, user_id, [group._id], [group.name])
return user_id, group
def setUp(self):
super(CallCenterSupervisorGroupTest, self).setUp()
self.domain = create_domain(self.domain_name)
self.supervisor = CommCareUser.create(self.domain_name, 'supervisor@' + self.domain_name, '***')
self.supervisor_group = Group(
domain=self.domain_name,
name='supervisor group',
case_sharing=True,
users=[self.supervisor.get_id]
)
self.supervisor_group.save()
self.domain.call_center_config.enabled = True
self.domain.call_center_config.case_owner_id = self.supervisor_group.get_id
self.domain.call_center_config.case_type = 'cc_flw'
self.domain.save()
self.user = CommCareUser.create(self.domain_name, 'user@' + self.domain_name, '***')
sync_call_center_user_case(self.user)
load_data(self.domain_name, self.user.user_id)
def setUpClass(cls):
cls.domain = 'message-formatting-test'
cls.domain_obj = Domain(name=cls.domain)
cls.domain_obj.save()
cls.mobile_user = CommCareUser.create(
cls.domain,
'mobile1@message-formatting-test',
'12345',
first_name='Mobile',
last_name='User'
)
cls.web_user = WebUser.create(
cls.domain,
'web1@message-formatting-test',
'12345',
first_name='Web',
last_name='User'
)
cls.group = Group(domain=cls.domain, name='Test Group')
cls.group.save()
cls.location_type = LocationType.objects.create(
domain=cls.domain,
name='top-level',
code='top-level'
)
cls.location = SQLLocation.objects.create(
domain=cls.domain,
name='Test Location',
site_code='loc1234',
location_type=cls.location_type
)
cls.couch_location = cls.location.couch_location
def test_kafka_group_pillow(self):
domain = uuid.uuid4().hex
user_id = uuid.uuid4().hex
# make a group
group = Group(domain=domain, name='g1', users=[user_id])
group.save()
# send to kafka
since = get_topic_offset(topics.GROUP)
change_meta = change_meta_from_doc(
document=group.to_json(),
data_source_type=data_sources.SOURCE_COUCH,
data_source_name=Group.get_db().dbname,
)
producer.send_change(topics.GROUP, change_meta)
# send to elasticsearch
pillow = get_group_pillow()
pillow.process_changes(since=since, forever=False)
self.elasticsearch.indices.refresh(GROUP_INDEX_INFO.index)
# verify there
self._verify_group_in_es(group)
def create(self, domain, name):
group = Group(domain=domain, name=name)
self.add_group(group)
return group
def make_group(cls, name, domain=None):
domain = domain or cls.domain
group = Group(name=name, domain=domain, case_sharing=True)
GroupESFake.save_doc(group._doc)
return group
def test_group_reindexer(self):
group = Group(domain=DOMAIN, name='g1')
group.save()
call_command('ptop_reindexer_v2', 'group', cleanup=True, noinput=True)
self._assert_group_in_es(group)
def _setup_group(cls):
group = Group(name=cls.GROUP_NAME, domain=cls.DOMAIN_NAME)
GroupESFake.save_doc(group._doc)
cls.group = group
def create_group(name, *users):
group = Group(users=[user.user_id for user in users], name=name, domain=self.domain,
case_sharing=True)
group.save()
return group
def setUpClass(cls):
super(SchedulingRecipientTest, cls).setUpClass()
cls.domain_obj = create_domain(cls.domain)
cls.location_types = setup_location_types(cls.domain,
['country', 'state', 'city'])
cls.country_location = make_loc('usa',
domain=cls.domain,
type='country')
cls.state_location = make_loc('ma',
domain=cls.domain,
type='state',
parent=cls.country_location)
cls.city_location = make_loc('boston',
domain=cls.domain,
type='city',
parent=cls.state_location)
cls.mobile_user = CommCareUser.create(cls.domain, 'mobile', 'abc',
None, None)
cls.mobile_user.set_location(cls.city_location)
cls.mobile_user2 = CommCareUser.create(cls.domain, 'mobile2', 'abc',
None, None)
cls.mobile_user2.set_location(cls.state_location)
cls.mobile_user3 = CommCareUser.create(cls.domain, 'mobile3', 'abc',
None, None)
cls.mobile_user3.user_data['role'] = 'pharmacist'
cls.mobile_user3.save()
cls.mobile_user4 = CommCareUser.create(cls.domain, 'mobile4', 'abc',
None, None)
cls.mobile_user4.user_data['role'] = 'nurse'
cls.mobile_user4.save()
cls.mobile_user5 = CommCareUser.create(cls.domain, 'mobile5', 'abc',
None, None)
cls.mobile_user5.user_data['role'] = ['nurse', 'pharmacist']
cls.mobile_user5.save()
cls.web_user = WebUser.create(cls.domain, 'web', 'abc', None, None)
cls.web_user2 = WebUser.create(cls.domain, 'web2', 'abc', None, None)
cls.web_user2.user_data['role'] = 'nurse'
cls.web_user2.save()
cls.group = Group(domain=cls.domain, users=[cls.mobile_user.get_id])
cls.group.save()
cls.group2 = Group(domain=cls.domain,
users=[
cls.mobile_user.get_id,
cls.mobile_user3.get_id,
cls.mobile_user4.get_id,
cls.mobile_user5.get_id,
])
cls.group2.save()
cls.case_group = CommCareCaseGroup(domain=cls.domain)
cls.case_group.save()
cls.process_pillow_changes = process_pillow_changes(
'DefaultChangeFeedPillow')
cls.process_pillow_changes.add_pillow(get_case_messaging_sync_pillow())
return group
return None
owner = get_wrapped_owner(get_owner_id(case))
if owner and owner._id == user._id:
pass
elif owner is None:
# assign to user
_assign_case(case, user._id, user)
elif isinstance(owner, CommCareUser):
needed_owners = [owner._id, user._id]
matched = _get_matching_group(existing_groups.values(), needed_owners)
if matched:
_assign_case(case, matched._id, user)
else:
new_group = Group(
domain=case.domain,
name="{case} Owners (system)".format(case=case.name or case.type),
users=[owner._id, user._id],
case_sharing=True,
reporting=False,
metadata={
'hq-system': True,
}
)
new_group.save()
existing_groups[new_group._id] = new_group
_assign_case(case, new_group._id, user)
else:
assert isinstance(owner, Group)
if user._id not in owner.users:
owner.users.append(user._id)
def test_get_wrapped_group(self):
group = Group(domain=self.domain, name='wrapped-group-test')
group.save()
self.addCleanup(group.delete)
wrapped = get_wrapped_owner(group._id)
self.assertTrue(isinstance(wrapped, Group))
def test_assign_to_group(self):
group = Group(users=[], name='case-assignment-group', domain=self.domain)
group.save()
self._make_tree()
assign_case(self.primary.case_id, group._id, include_subcases=True, include_parent_cases=True)
self._check_state(new_owner_id=group._id, expected_changed=self.all)
def test_group_reindexer(self):
group = Group(domain=DOMAIN, name='g1')
group.save()
reindex_and_clean('group')
self._assert_group_in_es(group)
def test_update_groups_succeeds(self):
group = Group({"name": "test"})
group.save()
self.addCleanup(group.delete)
update(self.user, 'groups', [group._id])
self.assertEqual(self.user.get_group_ids()[0], group._id)
