def testCaseAPIResultJSON(self):
try:
case = CommCareCase()
# because of how setattr is overridden you have to set it to None in this wacky way
case._doc['type'] = None
case.save()
self.assertEqual(None, CommCareCase.get(case._id).type)
res_sanitized = CaseAPIResult(id=case._id, couch_doc=case, sanitize=True)
res_unsanitized = CaseAPIResult(id=case._id, couch_doc=case, sanitize=False)
json = res_sanitized.case_json
self.assertEqual(json['properties']['case_type'], '')
json = res_unsanitized.case_json
self.assertEqual(json['properties']['case_type'], None)
def get_cases(request, domain):
request_params = request.GET
if request.couch_user.is_commcare_user():
user_id = request.couch_user.get_id
else:
user_id = request_params.get("user_id", "")
if not user_id and not request.couch_user.is_web_user():
return HttpResponseBadRequest("Must specify user_id!")
ids_only = string_to_boolean(request_params.get("ids_only", "false"))
case_id = request_params.get("case_id", "")
footprint = string_to_boolean(request_params.get("footprint", "false"))
accessor = CaseAccessors(domain)
if toggles.HSPH_HACK.enabled(domain):
hsph_case_id = request_params.get('hsph_hack', None)
if hsph_case_id != 'None' and hsph_case_id and user_id:
case = accessor.get_case(hsph_case_id)
usercase_id = CommCareUser.get_by_user_id(
user_id).get_usercase_id()
usercase = accessor.get_case(usercase_id) if usercase_id else None
return json_response(
map(
lambda case: CaseAPIResult(
id=case['_id'], couch_doc=case, id_only=ids_only),
filter(None, [case, case.parent, usercase])))
def get_cases(request, domain):
if request.couch_user.is_commcare_user():
user_id = request.couch_user.get_id
else:
user_id = request.REQUEST.get("user_id", "")
if not user_id and not request.couch_user.is_web_user():
return HttpResponseBadRequest("Must specify user_id!")
ids_only = string_to_boolean(request.REQUEST.get("ids_only", "false"))
case_id = request.REQUEST.get("case_id", "")
footprint = string_to_boolean(request.REQUEST.get("footprint", "false"))
include_children = string_to_boolean(
request.REQUEST.get("include_children", "false"))
if case_id and not footprint and not include_children:
# short circuit everything else and just return the case
# NOTE: this allows any user in the domain to access any case given
# they know its ID, which is slightly different from the previous
# behavior (can only access things you own + footprint). If we want to
# change this contract we would need to update this to check the
# owned case list + footprint
case = CommCareCase.get(case_id)
assert case.domain == domain
cases = [CaseAPIResult(id=case_id, couch_doc=case, id_only=ids_only)]
class CaseAPIMiscTests(TestCase):
@classmethod
def setUpClass(cls):
super(CaseAPIMiscTests, cls).setUpClass()
cls.domain = uuid.uuid4().hex
cls.project = create_domain(cls.domain)
cls.username = uuid.uuid4().hex
cls.password = "******"
cls.user = CommCareUser.create(
cls.domain, format_username(cls.username, cls.domain),
cls.password)
@classmethod
def tearDownClass(cls):
cls.user.delete()
FormProcessorTestUtils.delete_all_cases_forms_ledgers(cls.domain)
cls.project.delete()
super(CaseAPIMiscTests, cls).tearDownClass()
def testCaseAPIResultJSON(self):
case = CommCareCase()
# because of how setattr is overridden you have to set it to None in this wacky way
case._doc['type'] = None
case.save()
self.addCleanup(case.delete)
self.assertEqual(None, CommCareCase.get(case.case_id).type)
res_sanitized = CaseAPIResult(domain=TEST_DOMAIN,
id=case.case_id,
couch_doc=case,
sanitize=True)
res_unsanitized = CaseAPIResult(domain=TEST_DOMAIN,
id=case.case_id,
couch_doc=case,
sanitize=False)
json = res_sanitized.case_json
self.assertEqual(json['properties']['case_type'], '')
json = res_unsanitized.case_json
self.assertEqual(json['properties']['case_type'], None)
return json_response(
map(
lambda case: CaseAPIResult(
id=case['_id'], couch_doc=case, id_only=ids_only),
filter(None, [case, case.parent, usercase])))
if case_id and not footprint:
# short circuit everything else and just return the case
# NOTE: this allows any user in the domain to access any case given
# they know its ID, which is slightly different from the previous
# behavior (can only access things you own + footprint). If we want to
# change this contract we would need to update this to check the
# owned case list + footprint
case = accessor.get_case(case_id)
assert case.domain == domain
cases = [CaseAPIResult(id=case_id, couch_doc=case, id_only=ids_only)]
else:
filters = get_filters_from_request_params(request_params)
status = api_closed_to_status(request_params.get('closed', 'false'))
case_type = filters.get('properties/case_type', None)
cases = get_filtered_cases(domain,
status=status,
case_type=case_type,
user_id=user_id,
filters=filters,
footprint=footprint,
ids_only=ids_only,
strip_history=True)
return json_response(cases)
couch_doc=case,
id_only=ids_only),
filter(None, [case, case.parent, usercase])))
if case_id and not footprint:
# short circuit everything else and just return the case
# NOTE: this allows any user in the domain to access any case given
# they know its ID, which is slightly different from the previous
# behavior (can only access things you own + footprint). If we want to
# change this contract we would need to update this to check the
# owned case list + footprint
case = accessor.get_case(case_id)
assert case.domain == domain
cases = [
CaseAPIResult(domain=domain,
id=case_id,
couch_doc=case,
id_only=ids_only)
]
else:
filters = get_filters_from_request_params(request_params)
status = api_closed_to_status(request_params.get('closed', 'false'))
case_type = filters.get('properties/case_type', None)
cases = get_filtered_cases(domain,
status=status,
case_type=case_type,
user_id=user_id,
filters=filters,
footprint=footprint,
ids_only=ids_only,
strip_history=True)
return json_response(cases)
class CaseAPITest(TestCase):
"""
Tests some of the Case API functions
"""
domain = TEST_DOMAIN
case_types = ['t1', 't2']
user_ids = ['TEST_API1', 'TEST_API2']
@classmethod
def setUpClass(cls):
super(CaseAPITest, cls).setUpClass()
create_domain(cls.domain)
cls.password = "******"
def create_user(username):
return CommCareUser.create(cls.domain,
format_username(username, cls.domain),
cls.password)
cls.users = [create_user(id) for id in cls.user_ids]
update_toggle_cache(toggles.CLOUDCARE_CACHE.slug, TEST_DOMAIN, True,
toggles.NAMESPACE_DOMAIN)
@classmethod
def tearDownClass(cls):
for user in cls.users:
django_user = user.get_django_user()
django_user.delete()
user.delete()
clear_toggle_cache(toggles.CLOUDCARE_CACHE.slug, TEST_DOMAIN,
toggles.NAMESPACE_DOMAIN)
super(CaseAPITest, cls).tearDownClass()
def setUp(self):
super(CaseAPITest, self).setUp()
def create_case_set(user, child_user):
# for each user we need one open and one closed case of
# two different types.
for type in self.case_types:
c1 = _create_case(user, type, close=False) # open
_create_case(user, type, close=True) # closed
# child
_create_case(child_user,
_child_case_type(type),
close=False,
index={'parent': ('parent-case', c1.case_id)})
for i, user in enumerate(self.users):
create_case_set(user, self.users[(i + 1) % len(self.users)])
self.test_type = self.case_types[0]
self.test_user_id = self.users[0]._id
def tearDown(self):
FormProcessorTestUtils.delete_all_cases_forms_ledgers(TEST_DOMAIN)
super(CaseAPITest, self).tearDown()
def assertListMatches(self, list, function):
for item in list:
self.assertTrue(function(item))
@property
def expectedOpenByType(self):
return len(self.user_ids)
@property
def expectedClosedByType(self):
return len(self.user_ids)
@property
def expectedByType(self):
return self.expectedOpenByType + self.expectedClosedByType
@property
def expectedOpenByUser(self):
return len(self.case_types) * 2 # one per type and child type
@property
def expectedClosedByUser(self):
return len(self.case_types)
@property
def expectedByUser(self):
return self.expectedOpenByUser + self.expectedClosedByUser
@property
def expectedOpenByUserWithFootprint(self):
# each user gets 1 additional child case belonging to their cases
# for each case type
return self.expectedOpenByUser + len(self.case_types)
@property
def expectedClosedByUserWithFootprint(self):
# each user gets 1 additional child case belonging to their cases
return self.expectedClosedByUser
@property
def expectedOpen(self):
return self.expectedOpenByUser * len(self.user_ids)
@property
def expectedClosed(self):
return self.expectedClosedByUser * len(self.user_ids)
@property
def expectedAll(self):
return len(self.user_ids) * len(self.case_types) * 3
@run_with_all_backends
def testGetAllOpen(self):
list = get_filtered_cases(self.domain, status=CASE_STATUS_OPEN)
self.assertEqual(self.expectedOpen, len(list))
self.assertListMatches(list, lambda c: not c['closed'])
@run_with_all_backends
def testGetAllWithClosed(self):
list = get_filtered_cases(self.domain, status=CASE_STATUS_ALL)
self.assertEqual(self.expectedOpen + self.expectedClosed, len(list))
@run_with_all_backends
def testGetAllOpenWithType(self):
list = get_filtered_cases(self.domain,
status=CASE_STATUS_OPEN,
case_type=self.test_type)
self.assertEqual(self.expectedOpenByType, len(list))
self.assertListMatches(
list, lambda c: not c['closed'] and c['properties']['case_type'] ==
self.test_type)
@run_with_all_backends
def testGetAllWithClosedAndType(self):
list = get_filtered_cases(self.domain,
status=CASE_STATUS_ALL,
case_type=self.test_type)
self.assertEqual(self.expectedByType, len(list))
self.assertListMatches(
list, lambda c: c['properties']['case_type'] == self.test_type)
@run_with_all_backends
def testGetOwnedOpen(self):
list = get_filtered_cases(self.domain,
user_id=self.test_user_id,
status=CASE_STATUS_OPEN,
footprint=False)
self.assertEqual(self.expectedOpenByUser, len(list))
self.assertListMatches(
list,
lambda c: not c['closed'] and c['user_id'] == self.test_user_id)
@run_with_all_backends
def testGetOwnedClosed(self):
list = get_filtered_cases(self.domain,
user_id=self.test_user_id,
status=CASE_STATUS_CLOSED,
footprint=False)
self.assertEqual(self.expectedClosedByUser, len(list))
self.assertListMatches(
list, lambda c: c['closed'] and c['user_id'] == self.test_user_id)
@run_with_all_backends
def testGetOwnedBoth(self):
list = get_filtered_cases(self.domain,
user_id=self.test_user_id,
status=CASE_STATUS_ALL,
footprint=False)
self.assertEqual(self.expectedByUser, len(list))
self.assertListMatches(list,
lambda c: c['user_id'] == self.test_user_id)
@run_with_all_backends
def testGetOwnedOpenWithFootprint(self):
list = get_filtered_cases(self.domain,
user_id=self.test_user_id,
status=CASE_STATUS_OPEN,
footprint=True)
self.assertEqual(self.expectedOpenByUserWithFootprint, len(list))
self.assertListMatches(
list,
lambda c: not c['closed'] or c['user_id'] != self.test_user_id)
@run_with_all_backends
def testGetOwnedClosedWithFootprint(self):
list = get_filtered_cases(self.domain,
user_id=self.test_user_id,
status=CASE_STATUS_CLOSED,
footprint=True)
self.assertEqual(self.expectedClosedByUserWithFootprint, len(list))
self.assertListMatches(
list, lambda c: c['closed'] or c['user_id'] != self.test_user_id)
@run_with_all_backends
def testGetOwnedBothWithFootprint(self):
list = get_filtered_cases(self.domain,
user_id=self.test_user_id,
status=CASE_STATUS_ALL,
footprint=True)
self.assertEqual(
self.expectedOpenByUserWithFootprint +
self.expectedClosedByUserWithFootprint, len(list))
# I don't think we can say anything super useful about this base set
def testGetAllStripHistory(self):
# strip history doesn't work on SQL domains
list = get_filtered_cases(self.domain,
status=CASE_STATUS_ALL,
footprint=True,
strip_history=True)
self.assertEqual(self.expectedAll, len(list))
self.assertListMatches(list, lambda c: len(c._couch_doc.actions) == 0)
self.assertListMatches(list,
lambda c: len(c._couch_doc.xform_ids) == 0)
@run_with_all_backends
def testGetAllIdsOnly(self):
list = get_filtered_cases(self.domain,
status=CASE_STATUS_ALL,
footprint=True,
ids_only=True)
self.assertEqual(self.expectedAll, len(list))
self.assertListMatches(list, lambda c: c._couch_doc is None)
self.assertListMatches(list,
lambda c: isinstance(c.to_json(), basestring))
@run_with_all_backends
def testFiltersOnAll(self):
list = get_filtered_cases(
self.domain,
status=CASE_STATUS_ALL,
filters={"properties/case_name": _type_to_name(self.test_type)})
self.assertEqual(self.expectedByType, len(list))
self.assertListMatches(
list, lambda c: c['properties']['case_name'] == _type_to_name(
self.test_type))
@run_with_all_backends
def testFiltersOnOwned(self):
list = get_filtered_cases(
self.domain,
user_id=self.test_user_id,
status=CASE_STATUS_ALL,
filters={"properties/case_name": _type_to_name(self.test_type)})
self.assertEqual(2, len(list))
self.assertListMatches(
list, lambda c: c['properties']['case_name'] == _type_to_name(
self.test_type))
@run_with_all_backends
def testFiltersWithoutFootprint(self):
name = _type_to_name(_child_case_type(self.test_type))
list = get_filtered_cases(self.domain,
user_id=self.test_user_id,
status=CASE_STATUS_ALL,
footprint=False,
filters={"properties/case_name": name})
self.assertEqual(1, len(list))
self.assertListMatches(list,
lambda c: c['properties']['case_name'] == name)
@run_with_all_backends
def testFiltersWithFootprint(self):
name = _type_to_name(_child_case_type(self.test_type))
list = get_filtered_cases(self.domain,
user_id=self.test_user_id,
status=CASE_STATUS_ALL,
footprint=True,
filters={"properties/case_name": name})
# when filtering with footprint, the filters get intentionally ignored
# so just ensure the whole footprint including open and closed is available
self.assertEqual(
self.expectedOpenByUserWithFootprint +
self.expectedClosedByUserWithFootprint, len(list))
def testCaseAPIResultJSON(self):
case = CommCareCase()
# because of how setattr is overridden you have to set it to None in this wacky way
case._doc['type'] = None
case.save()
self.addCleanup(case.delete)
self.assertEqual(None, CommCareCase.get(case.case_id).type)
res_sanitized = CaseAPIResult(domain=TEST_DOMAIN,
id=case.case_id,
couch_doc=case,
sanitize=True)
res_unsanitized = CaseAPIResult(domain=TEST_DOMAIN,
id=case.case_id,
couch_doc=case,
sanitize=False)
json = res_sanitized.case_json
self.assertEqual(json['properties']['case_type'], '')
json = res_unsanitized.case_json
self.assertEqual(json['properties']['case_type'], None)