def setupFixtureData(cls):
cls.fixture_data = {
'schedule1': '7',
'schedule2': '14',
'schedule3': '21',
}
cls.data_type = FixtureDataType(
domain=cls.domain,
tag=DAILY_SCHEDULE_FIXTURE_NAME,
name=DAILY_SCHEDULE_FIXTURE_NAME,
fields=[
FixtureTypeField(field_name=SCHEDULE_ID_FIXTURE,
properties=[]),
FixtureTypeField(field_name="doses_per_week", properties=[]),
],
item_attributes=[],
)
cls.data_type.save()
cls.data_items = []
for _id, value in cls.fixture_data.iteritems():
data_item = FixtureDataItem(
domain=cls.domain,
data_type_id=cls.data_type.get_id,
fields={
SCHEDULE_ID_FIXTURE:
FieldList(
field_list=[FixtureItemField(field_value=_id, )]),
"doses_per_week":
FieldList(
field_list=[FixtureItemField(field_value=value, )])
},
item_attributes={},
)
data_item.save()
cls.data_items.append(data_item)
def make_data_item(location_name, cost):
"""Make a fixture data item and assign it to location_name"""
data_item = FixtureDataItem(
domain=cls.domain,
data_type_id=data_type.get_id,
fields={
"cost": FieldList(
field_list=[FixtureItemField(
field_value=cost,
properties={},
)]
),
"location_name": FieldList(
field_list=[FixtureItemField(
field_value=location_name,
properties={},
)]
),
},
item_attributes={},
)
data_item.save()
FixtureOwnership(
domain=cls.domain,
owner_id=cls.locations[location_name].location_id,
owner_type='location',
data_item_id=data_item.get_id
).save()
def make_data_item(location_name, cost):
"""Make a fixture data item and assign it to location_name"""
data_item = FixtureDataItem(
domain=cls.domain,
data_type_id=data_type.get_id,
fields={
"cost": FieldList(
field_list=[FixtureItemField(
field_value=cost,
properties={},
)]
),
"location_name": FieldList(
field_list=[FixtureItemField(
field_value=location_name,
properties={},
)]
),
},
item_attributes={},
)
data_item.save()
FixtureOwnership(
domain=cls.domain,
owner_id=cls.locations[location_name].location_id,
owner_type='location',
data_item_id=data_item.get_id
).save()
def _setup_data_item(self, risk='risk1', sequence='1', message='message1'):
data_item = FixtureDataItem(
domain=self.domain_name,
data_type_id=self.data_type.get_id,
fields={
"risk_profile": FieldList(
field_list=[
FixtureItemField(
field_value=risk,
properties={}
)
]
),
"sequence": FieldList(
field_list=[
FixtureItemField(
field_value=sequence,
properties={}
)
]
),
"message": FieldList(
field_list=[
FixtureItemField(
field_value=message,
properties={}
)
]
),
},
item_attributes={},
)
data_item.save()
self.addCleanup(data_item.delete)
def _create_data_item(self, cleanup=True):
data_item = FixtureDataItem(domain=self.domain.name,
data_type_id=self.data_type._id,
fields={
"state_name":
FieldList.wrap({
"field_list": [
{
"field_value": "Tennessee",
"properties": {
"lang": "en"
}
},
{
"field_value": "田納西",
"properties": {
"lang": "zh"
}
},
]
})
},
item_attributes={},
sort_key=1)
data_item.save()
if cleanup:
self.addCleanup(data_item.delete)
return data_item
def setupFixtureData(cls):
cls.fixture_data = [
{
SCHEDULE_ID_FIXTURE: 'schedule1',
'doses_per_week': '7',
'dose_count_ip_new_patient': '56',
'dose_count_ip_recurring_patient': '84',
'dose_count_cp_new_patient': '112',
'dose_count_cp_recurring_patient': '140',
'dose_count_outcome_due_new_patient': '168',
'dose_count_outcome_due_recurring_patient': '168',
},
{
SCHEDULE_ID_FIXTURE: 'schedule2',
'doses_per_week': '14',
'dose_count_ip_new_patient': '24',
'dose_count_ip_recurring_patient': '36',
'dose_count_cp_new_patient': '54',
'dose_count_cp_recurring_patient': '66',
'dose_count_outcome_due_new_patient': '78',
'dose_count_outcome_due_recurring_patient': '78',
},
{
SCHEDULE_ID_FIXTURE: 'schedule3',
'doses_per_week': '21',
'dose_count_ip_new_patient': '24',
'dose_count_ip_recurring_patient': '36',
'dose_count_cp_new_patient': '54',
'dose_count_cp_recurring_patient': '66',
'dose_count_outcome_due_new_patient': '78',
'dose_count_outcome_due_recurring_patient': '78',
},
]
cls.data_type = FixtureDataType(
domain=cls.domain,
tag=DAILY_SCHEDULE_FIXTURE_NAME,
name=DAILY_SCHEDULE_FIXTURE_NAME,
fields=[
FixtureTypeField(field_name=SCHEDULE_ID_FIXTURE,
properties=[]),
FixtureTypeField(field_name="doses_per_week", properties=[]),
],
item_attributes=[],
)
cls.data_type.save()
cls.data_items = []
for row in cls.fixture_data:
data_item = FixtureDataItem(
domain=cls.domain,
data_type_id=cls.data_type.get_id,
fields={
column_name: FieldList(
field_list=[FixtureItemField(field_value=value, )])
for column_name, value in six.iteritems(row)
},
item_attributes={},
)
data_item.save()
cls.data_items.append(data_item)
def post(self, request):
"""View's dispatch method automatically calls this"""
try:
workbook = WorkbookJSONReader(request.file)
except AttributeError:
return HttpResponseBadRequest("Error processing your Excel (.xlsx) file")
try:
data_types = workbook.get_worksheet(title='types')
except KeyError:
return HttpResponseBadRequest("Workbook does not have a sheet called 'types'")
for dt in data_types:
print "DataType"
print dt
for di in workbook.get_worksheet(title=dt['tag']):
print "DataItem"
print di
for dt in data_types:
data_type = FixtureDataType(
domain=self.domain,
name=dt['name'],
tag=dt['tag'],
fields=dt['field'],
)
data_type.save()
data_items = workbook.get_worksheet(data_type.tag)
for di in data_items:
print di
data_item = FixtureDataItem(
domain=self.domain,
data_type_id=data_type.get_id,
fields=di['field']
)
data_item.save()
for group_name in di.get('group', []):
group = Group.by_name(self.domain, group_name)
if group:
data_item.add_group(group)
else:
messages.error(request, "Unknown group: %s" % group_name)
for raw_username in di.get('user', []):
username = normalize_username(raw_username, self.domain)
user = CommCareUser.get_by_username(username)
if user:
data_item.add_user(user)
else:
messages.error(request, "Unknown user: %s" % raw_username)
return HttpResponseRedirect(reverse('fixture_view', args=[self.domain]))
def data_items(request, domain, data_type_id, data_item_id):
def prepare_item(item):
ret = strip_json(item, disallow=['data_type_id'])
if request.GET.get('groups') == 'true':
ret['groups'] = []
for group in item.get_groups():
ret['groups'].append(strip_json(group))
if request.GET.get('users') == 'true':
ret['users'] = []
for user in item.get_users():
ret['users'].append(prepare_user(user))
return ret
if request.method == 'POST' and data_item_id is None:
o = FixtureDataItem(domain=domain, data_type_id=data_type_id, **_to_kwargs(request))
o.save()
return json_response(strip_json(o, disallow=['data_type_id']))
elif request.method == 'GET' and data_item_id is None:
return json_response([
prepare_item(x)
for x in sorted(FixtureDataItem.by_data_type(domain, data_type_id),
key=lambda x: x.sort_key)
])
elif request.method == 'GET' and data_item_id:
try:
o = FixtureDataItem.get(data_item_id)
except ResourceNotFound:
raise Http404()
assert(o.domain == domain and o.data_type.get_id == data_type_id)
return json_response(prepare_item(o))
elif request.method == 'PUT' and data_item_id:
original = FixtureDataItem.get(data_item_id)
new = FixtureDataItem(domain=domain, **_to_kwargs(request))
for attr in 'fields',:
setattr(original, attr, getattr(new, attr))
original.save()
return json_response(strip_json(original, disallow=['data_type_id']))
elif request.method == 'DELETE' and data_item_id:
o = FixtureDataItem.get(data_item_id)
assert(o.domain == domain and o.data_type.get_id == data_type_id)
with CouchTransaction() as transaction:
o.recursive_delete(transaction)
return json_response({})
else:
return HttpResponseBadRequest()
def save(self):
data_type = FixtureDataType.by_domain_tag(self.objects.domain, self.objects.tag).one()
if data_type is None:
raise Dhis2ConfigurationError(
'Unable to find lookup table in domain "%s" with ID "%s".' %
(self.objects.domain, self.objects.tag))
data_item = FixtureDataItem(
data_type_id=data_type.get_id,
domain=self.objects.domain,
fields={
'id': to_field_list(self.id),
'name': to_field_list(self.name),
'parent_id': to_field_list(self.parent_id)
})
data_item.save()
self._fixture_id = data_item.get_id
return self._fixture_id
def _make_data_item(cls, sort_key, name, seat, sigil):
def field_list(value):
return FieldList(field_list=[FixtureItemField(field_value=value, properties={})])
data_item = FixtureDataItem(
domain=cls.domain,
data_type_id=cls.data_type._id,
fields={
"name": field_list(name),
"seat": field_list(seat),
"sigil": field_list(sigil),
},
item_attributes={},
sort_key=sort_key,
)
data_item.save()
return data_item
def make_data_item(self, data_type, cost):
data_item = FixtureDataItem(
domain=self.domain,
data_type_id=data_type._id,
fields={
"cost": FieldList(
field_list=[FixtureItemField(
field_value=cost,
properties={},
)]
),
},
item_attributes={},
)
data_item.save()
self.addCleanup(data_item.delete)
return data_item
def data_items(request, domain, data_type_id, data_item_id):
def prepare_item(item):
ret = strip_json(item, disallow=['data_type_id'])
if request.GET.get('groups') == 'true':
ret['groups'] = []
for group in item.get_groups():
ret['groups'].append(strip_json(group))
if request.GET.get('users') == 'true':
ret['users'] = []
for user in item.get_users():
ret['users'].append(prepare_user(user))
return ret
if request.method == 'POST' and data_item_id is None:
o = FixtureDataItem(domain=domain, data_type_id=data_type_id, **_to_kwargs(request))
o.save()
return json_response(strip_json(o, disallow=['data_type_id']))
elif request.method == 'GET' and data_item_id is None:
return json_response([
prepare_item(x)
for x in sorted(FixtureDataItem.by_data_type(domain, data_type_id),
key=lambda x: x.sort_key)
])
elif request.method == 'GET' and data_item_id:
try:
o = FixtureDataItem.get(data_item_id)
except ResourceNotFound:
raise Http404()
assert(o.domain == domain and o.data_type.get_id == data_type_id)
return json_response(prepare_item(o))
elif request.method == 'PUT' and data_item_id:
original = FixtureDataItem.get(data_item_id)
new = FixtureDataItem(domain=domain, **_to_kwargs(request))
for attr in 'fields',:
setattr(original, attr, getattr(new, attr))
original.save()
return json_response(strip_json(original, disallow=['data_type_id']))
elif request.method == 'DELETE' and data_item_id:
o = FixtureDataItem.get(data_item_id)
assert(o.domain == domain and o.data_type.get_id == data_type_id)
with CouchTransaction() as transaction:
o.recursive_delete(transaction)
return json_response({})
else:
return HttpResponseBadRequest()
def _create_data_item(self, cleanup=True):
data_item = FixtureDataItem(
domain=self.domain.name,
data_type_id=self.data_type._id,
fields={
"state_name": FieldList.wrap({
"field_list": [
{"field_value": "Tennessee", "properties": {"lang": "en"}},
{"field_value": "田納西", "properties": {"lang": "zh"}},
]})
},
item_attributes={},
sort_key=1
)
data_item.save()
if cleanup:
self.addCleanup(data_item.delete)
return data_item
def setUp(self):
self.domain = 'qwerty'
self.tag = "contact"
self.data_type = FixtureDataType(
domain=self.domain,
tag=self.tag,
name="Contact",
fields=['name', 'number']
)
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
'name': 'John',
'number': '+15555555555'
}
)
self.data_item.save()
for name, number in [('Michael', '+16666666666'),
('Eric', '+17777777777')]:
data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
'name': name,
'number': number,
}
)
data_item.save()
self.user = CommCareUser.create(self.domain, 'rudolph', '***')
self.fixture_ownership = FixtureOwnership(
domain=self.domain,
owner_id=self.user.get_id,
owner_type='user',
data_item_id=self.data_item.get_id
)
self.fixture_ownership.save()
def save(self):
if self.objects is None:
raise FixtureManagerError(
'FixtureManager not set. '
'e.g. `Dhis2OrgUnit.objects = FixtureManager(Dhis2OrgUnit, domain, ORG_UNIT_FIXTURES)`')
data_type = FixtureDataType.by_domain_tag(self.objects.domain, self.objects.tag).one()
if data_type is None:
raise Dhis2ConfigurationError(
'Unable to find lookup table in domain "%s" with ID "%s".' %
(self.objects.domain, self.objects.tag))
data_item = FixtureDataItem(
data_type_id=data_type.get_id,
domain=self.objects.domain,
fields={
'id': to_field_list(self.id),
'name': to_field_list(self.name),
'parent_id': to_field_list(self.parent_id)
})
data_item.save()
self._fixture_id = data_item.get_id
return self._fixture_id
def _setup_data_item(self, risk='risk1', sequence='1', message='message1'):
data_item = FixtureDataItem(
domain=self.domain_name,
data_type_id=self.data_type.get_id,
fields={
"risk_profile":
FieldList(field_list=[
FixtureItemField(field_value=risk, properties={})
]),
"sequence":
FieldList(field_list=[
FixtureItemField(field_value=sequence, properties={})
]),
"message":
FieldList(field_list=[
FixtureItemField(field_value=message, properties={})
]),
},
item_attributes={},
)
data_item.save()
self.addCleanup(data_item.delete)
def data_items(request, domain, data_type_id, data_item_id):
def prepare_item(item):
ret = strip_json(item, disallow=['data_type_id'])
if request.GET.get('groups') == 'true':
ret['groups'] = []
for group in item.get_groups():
ret['groups'].append(strip_json(group))
if request.GET.get('users') == 'true':
ret['users'] = []
for user in item.get_users():
ret['users'].append(prepare_user(user))
return ret
if request.method == 'POST' and data_item_id is None:
o = FixtureDataItem(domain=domain, data_type_id=data_type_id, **_to_kwargs(request))
o.save()
return json_response(strip_json(o, disallow=['data_type_id']))
elif request.method == 'GET' and data_item_id is None:
return json_response([prepare_item(x) for x in FixtureDataItem.by_data_type(domain, data_type_id)])
elif request.method == 'GET' and data_item_id:
o = FixtureDataItem.get(data_item_id)
assert(o.domain == domain and o.data_type.get_id == data_type_id)
return json_response(prepare_item(o))
elif request.method == 'PUT' and data_item_id:
original = FixtureDataItem.get(data_item_id)
new = FixtureDataItem(domain=domain, **_to_kwargs(request))
for attr in 'fields',:
setattr(original, attr, getattr(new, attr))
original.save()
return json_response(strip_json(original, disallow=['data_type_id']))
elif request.method == 'DELETE' and data_item_id:
o = FixtureDataItem.get(data_item_id)
assert(o.domain == domain and o.data_type.get_id == data_type_id)
o.delete()
return json_response({})
else:
return HttpResponseBadRequest()
def make_item_lists(tag, item_name):
data_type = FixtureDataType(
domain=DOMAIN,
tag=tag,
name="Provinces",
fields=[FixtureTypeField(field_name="name", properties=[])],
item_attributes=[],
is_global=True
)
data_type.save()
data_item = FixtureDataItem(
domain=DOMAIN,
data_type_id=data_type.get_id,
fields={
"name": FieldList(
field_list=[FixtureItemField(field_value=item_name, properties={})]
)
},
item_attributes={},
)
data_item.save()
return data_type, data_item
def make_item_lists(tag, item_name):
data_type = FixtureDataType(
domain=DOMAIN,
tag=tag,
name="Provinces",
fields=[FixtureTypeField(field_name="name", properties=[])],
item_attributes=[],
is_global=True
)
data_type.save()
data_item = FixtureDataItem(
domain=DOMAIN,
data_type_id=data_type.get_id,
fields={
"name": FieldList(
field_list=[FixtureItemField(field_value=item_name, properties={})]
)
},
item_attributes={},
)
data_item.save()
return data_type, data_item
class FixtureDataTest(TestCase):
def setUp(self):
self.domain = 'qwerty'
self.data_type = FixtureDataType(domain=self.domain,
tag="contact",
name="Contact",
fields=['name', 'number'])
self.data_type.save()
self.data_item = FixtureDataItem(domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
'name': 'John',
'number': '+15555555555'
})
self.data_item.save()
self.user = CommCareUser.create(self.domain, 'rudolph', '***')
self.fixture_ownership = FixtureOwnership(
domain=self.domain,
owner_id=self.user.get_id,
owner_type='user',
data_item_id=self.data_item.get_id)
self.fixture_ownership.save()
def tearDown(self):
self.data_type.delete()
self.data_item.delete()
self.user.delete()
self.fixture_ownership.delete()
def test_xml(self):
check_xml_line_by_line(
self, """
<contact>
<name>John</name>
<number>+15555555555</number>
</contact>
""", ElementTree.tostring(self.data_item.to_xml()))
def test_ownership(self):
self.assertItemsEqual([self.data_item.get_id],
FixtureDataItem.by_user(self.user, wrap=False))
self.assertItemsEqual([self.user.get_id],
self.data_item.get_all_users(wrap=False))
fixture, = fixturegenerators.item_lists(self.user)
check_xml_line_by_line(
self, """
<fixture id="item-list:contact" user_id="%s">
<contact_list>
<contact>
<name>John</name>
<number>+15555555555</number>
</contact>
</contact_list>
</fixture>
""" % self.user.user_id, ElementTree.tostring(fixture))
self.data_item.remove_user(self.user)
self.assertItemsEqual([], self.data_item.get_all_users())
self.fixture_ownership = self.data_item.add_user(self.user)
self.assertItemsEqual([self.user.get_id],
self.data_item.get_all_users(wrap=False))
class FieldNameCleanTest(TestCase):
"""Makes sure that bad characters are properly escaped in the xml
"""
def setUp(self):
self.domain = 'dirty-fields'
self.data_type = FixtureDataType(
domain=self.domain,
tag='dirty_fields',
name="Dirty Fields",
fields=[
FixtureTypeField(field_name="will/crash", properties=[]),
FixtureTypeField(field_name="space cadet", properties=[]),
FixtureTypeField(field_name="yes\\no", properties=[]),
FixtureTypeField(field_name="<with>", properties=[]),
FixtureTypeField(field_name="<crazy / combo><d", properties=[])
],
item_attributes=[],
)
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
"will/crash":
FieldList(field_list=[
FixtureItemField(field_value="yep", properties={})
]),
"space cadet":
FieldList(field_list=[
FixtureItemField(field_value="major tom", properties={})
]),
"yes\\no":
FieldList(field_list=[
FixtureItemField(field_value="no, duh", properties={})
]),
"<with>":
FieldList(field_list=[
FixtureItemField(field_value="so fail", properties={})
]),
"<crazy / combo><d":
FieldList(field_list=[
FixtureItemField(field_value="just why", properties={})
]),
"xmlbad":
FieldList(field_list=[
FixtureItemField(field_value="badxml", properties={})
])
},
item_attributes={},
)
self.data_item.save()
def tearDown(self):
self.data_type.delete()
self.data_item.delete()
def test_cleaner(self):
check_xml_line_by_line(
self, """
<dirty_fields>
<will_crash>yep</will_crash>
<space_cadet>major tom</space_cadet>
<yes_no>no, duh</yes_no>
<_with_>so fail</_with_>
<_crazy___combo__d>just why</_crazy___combo__d>
</dirty_fields>
""", ElementTree.tostring(self.data_item.to_xml()))
class FixtureDataTest(TestCase):
def setUp(self):
self.domain = 'qwerty'
self.tag = "district"
self.data_type = FixtureDataType(
domain=self.domain,
tag=self.tag,
name="Districts",
fields=[
FixtureTypeField(field_name="state_name", properties=[]),
FixtureTypeField(field_name="district_name",
properties=["lang"]),
FixtureTypeField(field_name="district_id", properties=[])
])
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
"state_name":
FieldList(field_list=[
FixtureItemField(field_value="Delhi_state", properties={})
]),
"district_name":
FieldList(field_list=[
FixtureItemField(field_value="Delhi_in_HIN",
properties={"lang": "hin"}),
FixtureItemField(field_value="Delhi_in_ENG",
properties={"lang": "eng"})
]),
"district_id":
FieldList(field_list=[
FixtureItemField(field_value="Delhi_id", properties={})
])
})
self.data_item.save()
self.user = CommCareUser.create(self.domain, 'to_delete', '***')
self.fixture_ownership = FixtureOwnership(
domain=self.domain,
owner_id=self.user.get_id,
owner_type='user',
data_item_id=self.data_item.get_id)
self.fixture_ownership.save()
def tearDown(self):
self.data_type.delete()
self.data_item.delete()
self.user.delete()
self.fixture_ownership.delete()
def test_xml(self):
check_xml_line_by_line(
self, """
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
""", ElementTree.tostring(self.data_item.to_xml()))
def test_ownership(self):
self.assertItemsEqual([self.data_item.get_id],
FixtureDataItem.by_user(self.user, wrap=False))
self.assertItemsEqual([self.user.get_id],
self.data_item.get_all_users(wrap=False))
fixture, = fixturegenerators.item_lists(self.user,
version=V2,
last_sync=None)
check_xml_line_by_line(
self, """
<fixture id="item-list:district" user_id="%s">
<district_list>
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
</district_list>
</fixture>
""" % self.user.user_id, ElementTree.tostring(fixture))
self.data_item.remove_user(self.user)
self.assertItemsEqual([], self.data_item.get_all_users())
self.fixture_ownership = self.data_item.add_user(self.user)
self.assertItemsEqual([self.user.get_id],
self.data_item.get_all_users(wrap=False))
def test_get_indexed_items(self):
with self.assertRaises(FixtureVersionError):
fixtures = FixtureDataItem.get_indexed_items(
self.domain, self.tag, 'state_name')
delhi_id = fixtures['Delhi_state']['district_id']
self.assertEqual(delhi_id, 'Delhi_id')
class FixtureDataTest(TestCase):
def setUp(self):
self.domain = 'qwerty'
self.data_type = FixtureDataType(
domain=self.domain,
tag="contact",
name="Contact",
fields=['name', 'number']
)
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
'name': 'John',
'number': '+15555555555'
}
)
self.data_item.save()
self.user = CommCareUser.create(self.domain, 'rudolph', '***')
self.fixture_ownership = FixtureOwnership(
domain=self.domain,
owner_id=self.user.get_id,
owner_type='user',
data_item_id=self.data_item.get_id
)
self.fixture_ownership.save()
def tearDown(self):
self.data_type.delete()
self.data_item.delete()
self.user.delete()
self.fixture_ownership.delete()
def test_xml(self):
check_xml_line_by_line(self, """
<contact>
<name>John</name>
<number>+15555555555</number>
</contact>
""", ElementTree.tostring(self.data_item.to_xml()))
def test_ownership(self):
self.assertItemsEqual([self.data_item.get_id], FixtureDataItem.by_user(self.user, wrap=False))
self.assertItemsEqual([self.user.get_id], self.data_item.get_all_users(wrap=False))
fixture, = fixturegenerators.item_lists(self.user)
check_xml_line_by_line(self, """
<fixture id="item-list:contact" user_id="%s">
<contact_list>
<contact>
<name>John</name>
<number>+15555555555</number>
</contact>
</contact_list>
</fixture>
""" % self.user.user_id, ElementTree.tostring(fixture))
self.data_item.remove_user(self.user)
self.assertItemsEqual([], self.data_item.get_all_users())
self.fixture_ownership = self.data_item.add_user(self.user)
self.assertItemsEqual([self.user.get_id], self.data_item.get_all_users(wrap=False))
class FixtureDataTest(TestCase):
def setUp(self):
self.domain = 'qwerty'
self.tag = "district"
self.data_type = FixtureDataType(
domain=self.domain,
tag=self.tag,
name="Districts",
fields=[
FixtureTypeField(
field_name="state_name",
properties=[]
),
FixtureTypeField(
field_name="district_name",
properties=["lang"]
),
FixtureTypeField(
field_name="district_id",
properties=[]
)
],
item_attributes=[],
)
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields= {
"state_name": FieldList(
field_list=[
FixtureItemField(
field_value="Delhi_state",
properties={}
)
]
),
"district_name": FieldList(
field_list=[
FixtureItemField(
field_value="Delhi_in_HIN",
properties={"lang": "hin"}
),
FixtureItemField(
field_value="Delhi_in_ENG",
properties={"lang": "eng"}
)
]
),
"district_id": FieldList(
field_list=[
FixtureItemField(
field_value="Delhi_id",
properties={}
)
]
)
},
item_attributes={},
)
self.data_item.save()
self.user = CommCareUser.create(self.domain, 'to_delete', '***')
self.fixture_ownership = FixtureOwnership(
domain=self.domain,
owner_id=self.user.get_id,
owner_type='user',
data_item_id=self.data_item.get_id
)
self.fixture_ownership.save()
def tearDown(self):
self.data_type.delete()
self.data_item.delete()
self.user.delete()
self.fixture_ownership.delete()
def test_xml(self):
check_xml_line_by_line(self, """
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
""", ElementTree.tostring(self.data_item.to_xml()))
def test_ownership(self):
self.assertItemsEqual([self.data_item.get_id], FixtureDataItem.by_user(self.user, wrap=False))
self.assertItemsEqual([self.user.get_id], self.data_item.get_all_users(wrap=False))
fixture, = fixturegenerators.item_lists(self.user, V2)
check_xml_line_by_line(self, """
<fixture id="item-list:district" user_id="%s">
<district_list>
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
</district_list>
</fixture>
""" % self.user.user_id, ElementTree.tostring(fixture))
self.data_item.remove_user(self.user)
self.assertItemsEqual([], self.data_item.get_all_users())
self.fixture_ownership = self.data_item.add_user(self.user)
self.assertItemsEqual([self.user.get_id], self.data_item.get_all_users(wrap=False))
def test_get_indexed_items(self):
with self.assertRaises(FixtureVersionError):
fixtures = FixtureDataItem.get_indexed_items(self.domain,
self.tag, 'state_name')
delhi_id = fixtures['Delhi_state']['district_id']
self.assertEqual(delhi_id, 'Delhi_id')
class FixtureDataTest(TestCase):
def setUp(self):
self.domain = 'qwerty'
self.tag = "contact"
self.data_type = FixtureDataType(
domain=self.domain,
tag=self.tag,
name="Contact",
fields=['name', 'number']
)
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
'name': 'John',
'number': '+15555555555'
}
)
self.data_item.save()
for name, number in [('Michael', '+16666666666'),
('Eric', '+17777777777')]:
data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
'name': name,
'number': number,
}
)
data_item.save()
self.user = CommCareUser.create(self.domain, 'rudolph', '***')
self.fixture_ownership = FixtureOwnership(
domain=self.domain,
owner_id=self.user.get_id,
owner_type='user',
data_item_id=self.data_item.get_id
)
self.fixture_ownership.save()
def tearDown(self):
self.data_type.delete()
self.data_item.delete()
self.user.delete()
self.fixture_ownership.delete()
def test_xml(self):
check_xml_line_by_line(self, """
<contact>
<name>John</name>
<number>+15555555555</number>
</contact>
""", ElementTree.tostring(self.data_item.to_xml()))
def test_ownership(self):
self.assertItemsEqual([self.data_item.get_id], FixtureDataItem.by_user(self.user, wrap=False))
self.assertItemsEqual([self.user.get_id], self.data_item.get_all_users(wrap=False))
fixture, = fixturegenerators.item_lists(self.user, version=V2, last_sync=None)
check_xml_line_by_line(self, """
<fixture id="item-list:contact" user_id="%s">
<contact_list>
<contact>
<name>John</name>
<number>+15555555555</number>
</contact>
</contact_list>
</fixture>
""" % self.user.user_id, ElementTree.tostring(fixture))
self.data_item.remove_user(self.user)
self.assertItemsEqual([], self.data_item.get_all_users())
self.fixture_ownership = self.data_item.add_user(self.user)
self.assertItemsEqual([self.user.get_id], self.data_item.get_all_users(wrap=False))
def test_get_indexed_items(self):
fixtures = FixtureDataItem.get_indexed_items(self.domain,
self.tag, 'name')
john_num = fixtures['John']['number']
self.assertEqual(john_num, '+15555555555')
class FixtureDataTest(TestCase):
def setUp(self):
super(FixtureDataTest, self).setUp()
self.domain = 'qwerty'
self.tag = "district"
delete_all_users()
delete_all_fixture_data_types()
self.data_type = FixtureDataType(
domain=self.domain,
tag=self.tag,
name="Districts",
fields=[
FixtureTypeField(
field_name="state_name",
properties=[]
),
FixtureTypeField(
field_name="district_name",
properties=["lang"]
),
FixtureTypeField(
field_name="district_id",
properties=[]
),
],
item_attributes=[],
)
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
"state_name": FieldList(
field_list=[
FixtureItemField(
field_value="Delhi_state",
properties={}
)
]
),
"district_name": FieldList(
field_list=[
FixtureItemField(
field_value="Delhi_in_HIN",
properties={"lang": "hin"}
),
FixtureItemField(
field_value="Delhi_in_ENG",
properties={"lang": "eng"}
)
]
),
"district_id": FieldList(
field_list=[
FixtureItemField(
field_value="Delhi_id",
properties={}
)
]
)
},
item_attributes={},
)
self.data_item.save()
self.user = CommCareUser.create(self.domain, 'to_delete', '***')
self.fixture_ownership = FixtureOwnership(
domain=self.domain,
owner_id=self.user.get_id,
owner_type='user',
data_item_id=self.data_item.get_id
)
self.fixture_ownership.save()
get_fixture_data_types.clear(self.domain)
def tearDown(self):
self.data_type.delete()
self.data_item.delete()
self.user.delete()
self.fixture_ownership.delete()
delete_all_users()
delete_all_fixture_data_types()
get_fixture_data_types.clear(self.domain)
get_blob_db().delete(key=FIXTURE_BUCKET + '/' + self.domain)
super(FixtureDataTest, self).tearDown()
def test_xml(self):
check_xml_line_by_line(self, """
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
""", ElementTree.tostring(self.data_item.to_xml()))
def test_ownership(self):
self.assertItemsEqual([self.data_item.get_id], FixtureDataItem.by_user(self.user, wrap=False))
self.assertItemsEqual([self.user.get_id], self.data_item.get_all_users(wrap=False))
fixture, = call_fixture_generator(self.user.to_ota_restore_user())
check_xml_line_by_line(self, """
<fixture id="item-list:district" user_id="%s">
<district_list>
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
</district_list>
</fixture>
""" % self.user.user_id, ElementTree.tostring(fixture))
self.data_item.remove_user(self.user)
self.assertItemsEqual([], self.data_item.get_all_users())
self.fixture_ownership = self.data_item.add_user(self.user)
self.assertItemsEqual([self.user.get_id], self.data_item.get_all_users(wrap=False))
def test_fixture_removal(self):
"""
An empty fixture list should be generated for each fixture that the
use does not have access to (within the domain).
"""
self.data_item.remove_user(self.user)
fixtures = call_fixture_generator(self.user.to_ota_restore_user())
self.assertEqual(1, len(fixtures))
check_xml_line_by_line(
self,
"""
<fixture id="item-list:district" user_id="{}">
<district_list />
</fixture>
""".format(self.user.user_id),
ElementTree.tostring(fixtures[0])
)
self.fixture_ownership = self.data_item.add_user(self.user)
def test_get_indexed_items(self):
with self.assertRaises(FixtureVersionError):
fixtures = FixtureDataItem.get_indexed_items(
self.domain, self.tag, 'state_name')
delhi_id = fixtures['Delhi_state']['district_id']
self.assertEqual(delhi_id, 'Delhi_id')
def test_get_item_by_field_value(self):
self.assertEqual(
FixtureDataItem.by_field_value(self.domain, self.data_type, 'state_name', 'Delhi_state').one().get_id,
self.data_item.get_id
)
def test_fixture_is_indexed(self):
self.data_type.fields[2].is_indexed = True # Set "district_id" as indexed
self.data_type.save()
fixtures = call_fixture_generator(self.user.to_ota_restore_user())
self.assertEqual(len(fixtures), 2)
check_xml_line_by_line(
self,
"""
<fixtures>
<schema id="item-list:district">
<indices>
<index>district_id</index>
</indices>
</schema>
<fixture id="item-list:district" indexed="true" user_id="{}">
<district_list>
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
</district_list>
</fixture>
</fixtures>
""".format(self.user.user_id),
"""
<fixtures>
{}
{}
</fixtures>
""".format(*[ElementTree.tostring(fixture).decode('utf-8') for fixture in fixtures])
)
def test_empty_data_types(self):
empty_data_type = FixtureDataType(
domain=self.domain,
tag='blank',
name="blank",
fields=[
FixtureTypeField(
field_name="name",
properties=[]
),
],
item_attributes=[],
)
empty_data_type.save()
self.addCleanup(empty_data_type.delete)
get_fixture_data_types.clear(self.domain)
fixtures = call_fixture_generator(self.user.to_ota_restore_user())
self.assertEqual(2, len(fixtures))
check_xml_line_by_line(
self,
"""
<f>
<fixture id="item-list:blank" user_id="{0}">
<blank_list/>
</fixture>
<fixture id="item-list:district" user_id="{0}">
<district_list>
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
</district_list>
</fixture>
</f>
""".format(self.user.user_id),
'<f>{}\n{}\n</f>'.format(*[ElementTree.tostring(fixture).decode('utf-8') for fixture in fixtures])
)
def test_user_data_type_with_item(self):
cookie = self.make_data_type("cookie", is_global=False)
latte = self.make_data_type("latte", is_global=True)
self.make_data_item(cookie, "2.50")
self.make_data_item(latte, "5.75")
fixtures = call_fixture_generator(self.user.to_ota_restore_user())
# make sure each fixture is there, and only once
self.assertEqual(
[item.attrib['id'] for item in fixtures],
[
'item-list:latte-index',
'item-list:cookie-index',
'item-list:district',
],
)
def test_empty_user_data_types(self):
self.make_data_type("cookie", is_global=False)
fixtures = call_fixture_generator(self.user.to_ota_restore_user())
# make sure each fixture is there, and only once
self.assertEqual(
[item.attrib['id'] for item in fixtures],
[
'item-list:cookie-index',
'item-list:district',
],
)
def test_cached_global_fixture_user_id(self):
sandwich = self.make_data_type("sandwich", is_global=True)
self.make_data_item(sandwich, "7.39")
frank = self.user.to_ota_restore_user()
sammy = CommCareUser.create(self.domain, 'sammy', '***').to_ota_restore_user()
fixtures = call_fixture_generator(frank)
self.assertEqual({item.attrib['user_id'] for item in fixtures}, {frank.user_id})
self.assertTrue(get_blob_db().exists(key=FIXTURE_BUCKET + '/' + self.domain))
fixtures = call_fixture_generator(sammy)
self.assertEqual({item.attrib['user_id'] for item in fixtures}, {sammy.user_id})
def make_data_type(self, name, is_global):
data_type = FixtureDataType(
domain=self.domain,
tag="{}-index".format(name),
is_global=is_global,
name=name.title(),
fields=[
FixtureTypeField(field_name="cost", properties=[]),
],
item_attributes=[],
)
data_type.save()
self.addCleanup(data_type.delete)
return data_type
def make_data_item(self, data_type, cost):
data_item = FixtureDataItem(
domain=self.domain,
data_type_id=data_type._id,
fields={
"cost": FieldList(
field_list=[FixtureItemField(
field_value=cost,
properties={},
)]
),
},
item_attributes={},
)
data_item.save()
self.addCleanup(data_item.delete)
return data_item
class FieldNameCleanTest(TestCase):
"""Makes sure that bad characters are properly escaped in the xml
"""
def setUp(self):
self.domain = 'dirty-fields'
self.data_type = FixtureDataType(
domain=self.domain,
tag='dirty_fields',
name="Dirty Fields",
fields=[
FixtureTypeField(
field_name="will/crash",
properties=[]
),
FixtureTypeField(
field_name="space cadet",
properties=[]
),
FixtureTypeField(
field_name="yes\\no",
properties=[]
),
FixtureTypeField(
field_name="<with>",
properties=[]
),
FixtureTypeField(
field_name="<crazy / combo><d",
properties=[]
)
],
item_attributes=[],
)
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
"will/crash": FieldList(
field_list=[
FixtureItemField(
field_value="yep",
properties={}
)
]
),
"space cadet": FieldList(
field_list=[
FixtureItemField(
field_value="major tom",
properties={}
)
]
),
"yes\\no": FieldList(
field_list=[
FixtureItemField(
field_value="no, duh",
properties={}
)
]
),
"<with>": FieldList(
field_list=[
FixtureItemField(
field_value="so fail",
properties={}
)
]
),
"<crazy / combo><d": FieldList(
field_list=[
FixtureItemField(
field_value="just why",
properties={}
)
]
),
"xmlbad": FieldList(
field_list=[
FixtureItemField(
field_value="badxml",
properties={}
)
]
)
},
item_attributes={},
)
self.data_item.save()
def tearDown(self):
self.data_type.delete()
self.data_item.delete()
def test_cleaner(self):
check_xml_line_by_line(self, """
<dirty_fields>
<will_crash>yep</will_crash>
<space_cadet>major tom</space_cadet>
<yes_no>no, duh</yes_no>
<_with_>so fail</_with_>
<_crazy___combo__d>just why</_crazy___combo__d>
</dirty_fields>
""", ElementTree.tostring(self.data_item.to_xml()))
class FixtureDataTest(TestCase):
def setUp(self):
super(FixtureDataTest, self).setUp()
self.domain = 'qwerty'
self.tag = "district"
delete_all_users()
delete_all_fixture_data_types()
self.data_type = FixtureDataType(
domain=self.domain,
tag=self.tag,
name="Districts",
fields=[
FixtureTypeField(field_name="state_name", properties=[]),
FixtureTypeField(field_name="district_name",
properties=["lang"]),
FixtureTypeField(field_name="district_id", properties=[]),
],
item_attributes=[],
)
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
"state_name":
FieldList(field_list=[
FixtureItemField(field_value="Delhi_state", properties={})
]),
"district_name":
FieldList(field_list=[
FixtureItemField(field_value="Delhi_in_HIN",
properties={"lang": "hin"}),
FixtureItemField(field_value="Delhi_in_ENG",
properties={"lang": "eng"})
]),
"district_id":
FieldList(field_list=[
FixtureItemField(field_value="Delhi_id", properties={})
])
},
item_attributes={},
)
self.data_item.save()
self.user = CommCareUser.create(self.domain, 'to_delete', '***')
self.fixture_ownership = FixtureOwnership(
domain=self.domain,
owner_id=self.user.get_id,
owner_type='user',
data_item_id=self.data_item.get_id)
self.fixture_ownership.save()
get_fixture_data_types_in_domain.clear(self.domain)
def tearDown(self):
self.data_type.delete()
self.data_item.delete()
self.user.delete()
self.fixture_ownership.delete()
delete_all_users()
delete_all_fixture_data_types()
get_fixture_data_types_in_domain.clear(self.domain)
super(FixtureDataTest, self).tearDown()
def test_xml(self):
check_xml_line_by_line(
self, """
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
""", ElementTree.tostring(self.data_item.to_xml()))
def test_ownership(self):
self.assertItemsEqual([self.data_item.get_id],
FixtureDataItem.by_user(self.user, wrap=False))
self.assertItemsEqual([self.user.get_id],
self.data_item.get_all_users(wrap=False))
fixture, = call_fixture_generator(fixturegenerators.item_lists,
self.user.to_ota_restore_user())
check_xml_line_by_line(
self, """
<fixture id="item-list:district" user_id="%s">
<district_list>
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
</district_list>
</fixture>
""" % self.user.user_id, ElementTree.tostring(fixture))
self.data_item.remove_user(self.user)
self.assertItemsEqual([], self.data_item.get_all_users())
self.fixture_ownership = self.data_item.add_user(self.user)
self.assertItemsEqual([self.user.get_id],
self.data_item.get_all_users(wrap=False))
def test_fixture_removal(self):
"""
An empty fixture list should be generated for each fixture that the
use does not have access to (within the domain).
"""
self.data_item.remove_user(self.user)
fixtures = call_fixture_generator(fixturegenerators.item_lists,
self.user.to_ota_restore_user())
self.assertEqual(1, len(fixtures))
check_xml_line_by_line(
self, """
<fixture id="item-list:district" user_id="{}">
<district_list />
</fixture>
""".format(self.user.user_id), ElementTree.tostring(fixtures[0]))
self.fixture_ownership = self.data_item.add_user(self.user)
def test_get_indexed_items(self):
with self.assertRaises(FixtureVersionError):
fixtures = FixtureDataItem.get_indexed_items(
self.domain, self.tag, 'state_name')
delhi_id = fixtures['Delhi_state']['district_id']
self.assertEqual(delhi_id, 'Delhi_id')
def test_get_item_by_field_value(self):
self.assertEqual(
FixtureDataItem.by_field_value(self.domain, self.data_type,
'state_name',
'Delhi_state').one().get_id,
self.data_item.get_id)
def test_fixture_is_indexed(self):
self.data_type.fields[
2].is_indexed = True # Set "district_id" as indexed
self.data_type.save()
fixtures = call_fixture_generator(fixturegenerators.item_lists,
self.user.to_ota_restore_user())
self.assertEqual(len(fixtures), 2)
check_xml_line_by_line(
self, """
<fixtures>
<schema id="item-list:district">
<indices>
<index>district_id</index>
</indices>
</schema>
<fixture id="item-list:district" indexed="true" user_id="{}">
<district_list>
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
</district_list>
</fixture>
</fixtures>
""".format(self.user.user_id), """
<fixtures>
{}
{}
</fixtures>
""".format(
*[ElementTree.tostring(fixture) for fixture in fixtures]))
def test_empty_data_types(self):
empty_data_type = FixtureDataType(
domain=self.domain,
tag='blank',
name="blank",
fields=[
FixtureTypeField(field_name="name", properties=[]),
],
item_attributes=[],
)
empty_data_type.save()
self.addCleanup(empty_data_type.delete)
get_fixture_data_types_in_domain.clear(self.domain)
fixtures = call_fixture_generator(fixturegenerators.item_lists,
self.user.to_ota_restore_user())
self.assertEqual(2, len(fixtures))
check_xml_line_by_line(
self, """
<f>
<fixture id="item-list:blank" user_id="{0}">
<blank_list/>
</fixture>
<fixture id="item-list:district" user_id="{0}">
<district_list>
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
</district_list>
</fixture>
</f>
""".format(self.user.user_id), '<f>{}\n{}\n</f>'.format(
*[ElementTree.tostring(fixture) for fixture in fixtures]))
