def setUpClass(cls):
from casexml.apps.case.tests.util import delete_all_xforms
delete_all_xforms()
cls.now = datetime.datetime.utcnow()
cls._60_days = datetime.timedelta(days=60)
cls.domain = 'my_crazy_analytics_domain'
cls.app_id = uuid.uuid4().hex
cls.xmlns = 'my://crazy.xmlns/'
cls.user_id = uuid.uuid4().hex
cls.forms = [
XFormInstance(
domain=cls.domain,
received_on=cls.now,
app_id=cls.app_id,
xmlns=cls.xmlns,
form={'meta': {
'userID': cls.user_id,
'username': '******'
}}),
XFormInstance(
domain=cls.domain,
received_on=cls.now - cls._60_days,
app_id=cls.app_id,
xmlns=cls.xmlns,
form={'meta': {
'userID': cls.user_id,
'username': '******'
}}),
]
cls.error_forms = [XFormError(domain=cls.domain)]
cls.all_forms = cls.forms + cls.error_forms
for form in cls.all_forms:
form.save()
update_analytics_indexes()
def setUpClass(cls):
from casexml.apps.case.tests import delete_all_xforms
delete_all_xforms()
cls.domain = 'evelyn'
cls.now = datetime.datetime.utcnow()
cls.xforms = [
XFormInstance(_id='xform_1',
received_on=cls.now - datetime.timedelta(days=10)),
XFormInstance(_id='xform_2', received_on=cls.now)
]
cls.xform_errors = [XFormError(_id='xform_error_1')]
for form in cls.xforms + cls.xform_errors:
form.domain = cls.domain
form.save()
def test_child_never_sick(self):
self.assertCondition(
True,
forms=[
XFormInstance(
received_on=datetime(2014, 5, 2),
xmlns=self.xmlns,
),
XFormInstance(
received_on=datetime(2014, 6, 12),
xmlns=self.xmlns,
),
],
child_age=9,
)
def _send_forms(self, forms):
# list of form tuples [(xmlns, received_on)]
to_ret = []
for xmlns, received_on in forms:
backend_form = XFormInstance(
xmlns=xmlns or 'fake-xmlns',
domain=self.domain.name,
received_on=received_on or datetime.utcnow(),
edited_on=datetime.utcnow(),
form={
'#type': 'fake-type',
'@xmlns': xmlns or 'fake-xmlns',
'meta': {
'userID': 'metadata-user-id'
},
},
auth_context={
'user_id': 'auth-user-id',
'domain': self.domain.name,
'authenticated': True,
},
)
backend_form.save()
to_ret.append(backend_form)
self.addCleanup(backend_form.delete)
send_to_elasticsearch(
'forms',
transform_xform_for_elasticsearch(backend_form.to_json()))
self.es.indices.refresh(XFORM_INDEX_INFO.index)
return to_ret
def get_forms(self):
"""
Gets the form docs associated with a case. If it can't find a form
it won't be included.
"""
forms = iter_docs(self.get_db(), self.xform_ids)
return [XFormInstance(form) for form in forms]
def testSignal(self):
global archive_counter, restore_counter
archive_counter = 0
restore_counter = 0
def count_archive(**kwargs):
global archive_counter
archive_counter += 1
def count_unarchive(**kwargs):
global restore_counter
restore_counter += 1
xform_archived.connect(count_archive)
xform_unarchived.connect(count_unarchive)
form = XFormInstance(form={'foo': 'bar'})
form.save()
self.assertEqual(0, archive_counter)
self.assertEqual(0, restore_counter)
form.archive()
self.assertEqual(1, archive_counter)
self.assertEqual(0, restore_counter)
form.unarchive()
self.assertEqual(1, archive_counter)
self.assertEqual(1, restore_counter)
def test_update_dependent_case_owner_still_present(self):
sync_log = SimplifiedSyncLog(
domain="domain",
case_ids_on_phone={'c1', 'd1'},
dependent_case_ids_on_phone={'d1'},
index_tree=IndexTree(indices={'c1': {
'd1-id': 'd1'
}}),
user_id="user",
owner_ids_on_phone={'user1'})
dependent_case_state = CaseState(case_id="d1", indices=[])
xform_id = uuid.uuid4().hex
xform = XFormInstance(_id=xform_id)
form_actions = [
CommCareCaseAction(action_type=CASE_ACTION_UPDATE,
updated_known_properties={'owner_id': 'user2'})
]
with patch.object(CommCareCase,
'get_actions_for_form',
return_value=form_actions):
parent_case = CommCareCase(_id='d1')
# before this test was added, the following call raised a ValueError on legacy logs.
sync_log.update_phone_lists(xform, [parent_case])
self.assertIn(dependent_case_state,
sync_log.test_only_get_dependent_cases_on_phone())
def testArchive(self):
form = XFormInstance(form={'foo': 'bar'})
form.save()
self.assertEqual("XFormInstance", form.doc_type)
self.assertEqual(0, len(form.history))
lower_bound = datetime.utcnow() - timedelta(seconds=1)
form.archive(user='******')
upper_bound = datetime.utcnow() + timedelta(seconds=1)
form = fetch_and_wrap_form(form._id)
self.assertEqual('XFormArchived', form.doc_type)
self.assertTrue(isinstance(form, XFormArchived))
[archival] = form.history
self.assertTrue(lower_bound <= archival.date <= upper_bound)
self.assertEqual('archive', archival.operation)
self.assertEqual('mr. librarian', archival.user)
lower_bound = datetime.utcnow() - timedelta(seconds=1)
form.unarchive(user='******')
upper_bound = datetime.utcnow() + timedelta(seconds=1)
form = fetch_and_wrap_form(form._id)
self.assertEqual('XFormInstance', form.doc_type)
self.assertTrue(isinstance(form, XFormInstance))
[archival, restoration] = form.history
self.assertTrue(lower_bound <= restoration.date <= upper_bound)
self.assertEqual('unarchive', restoration.operation)
self.assertEqual('mr. researcher', restoration.user)
def test_update_dependent_case(self):
sync_log = SyncLog(
cases_on_phone=[
CaseState(
case_id='bran',
indices=[
CommCareCaseIndex(identifier='legs',
referenced_id='hodor')
],
),
],
dependent_cases_on_phone=[CaseState(case_id='hodor')],
user_id="someuser")
xform_id = uuid.uuid4().hex
xform = XFormInstance(_id=xform_id)
form_actions = [CommCareCaseAction(action_type=CASE_ACTION_UPDATE, )]
with patch.object(CommCareCase,
'get_actions_for_form',
return_value=form_actions):
parent_case = CommCareCase(_id='hodor')
# before this test was added, the following call raised a SyncLogAssertionError on legacy logs.
# this test just ensures it doesn't still do that.
for log in [
sync_log,
SimplifiedSyncLog.from_other_format(sync_log)
]:
log.update_phone_lists(xform, [parent_case])
def get_all_stock_report_helpers_from_form(xform):
"""
Given an instance of an AbstractXFormInstance, extract the ledger actions and convert
them to StockReportHelper objects.
"""
form_xml = xform.get_xml_element()
commtrack_node_names = ('{%s}balance' % COMMTRACK_REPORT_XMLNS,
'{%s}transfer' % COMMTRACK_REPORT_XMLNS)
def _extract_ledger_nodes_from_xml(node):
"""
Goes through a parsed XML document and recursively pulls out any ledger XML blocks.
"""
for child in node:
if child.tag in commtrack_node_names:
yield child
else:
for e in _extract_ledger_nodes_from_xml(child):
yield e
for elem in _extract_ledger_nodes_from_xml(form_xml):
report_type, ledger_json = convert_xml_to_json(
elem, last_xmlns=COMMTRACK_REPORT_XMLNS)
# apply the same datetime & string conversions
# that would be applied to XFormInstance.form
adjust_datetimes(ledger_json)
ledger_json = XFormInstance({'form': ledger_json}).form
yield _ledger_json_to_stock_report_helper(xform, report_type,
ledger_json)
def _preg_form_with_vhnd_attendance(received_on):
return XFormInstance(
received_on=received_on,
xmlns=BIRTH_PREP_XMLNS,
form={'pregnancy_questions': {
'attendance_vhnd': '1'
}})
def check_form(self, received=None, months_before=None, months_after=None, xmlns=None):
form = XFormInstance(received_on=received or datetime(2014, 6, 15),
form={'foo': 'bar'},
xmlns=xmlns or 'moodys://falafel.palace')
case = OPMCase([form], dod=date(2014, 1, 10))
row = MockCaseRow(case, Report(month=6, year=2014, block="Atri"))
return len(row.filtered_forms(xmlns, months_before, months_after)) == 1
def test_update_dependent_case_owner_still_present(self):
dependent_case_state = CaseState(case_id="d1", indices=[])
sync_log = SyncLog(domain="domain",
user_id="user",
cases_on_phone=[
CaseState(case_id="c1",
indices=[
CommCareCaseIndex(
identifier="d1-id",
referenced_id="d1")
])
],
dependent_cases_on_phone=[dependent_case_state],
owner_ids_on_phone=['user1'])
xform_id = uuid.uuid4().hex
xform = XFormInstance(_id=xform_id)
form_actions = [
CommCareCaseAction(action_type=CASE_ACTION_UPDATE,
updated_known_properties={'owner_id': 'user2'})
]
with patch.object(CommCareCase,
'get_actions_for_form',
return_value=form_actions):
parent_case = CommCareCase(_id='d1')
# before this test was added, the following call raised a ValueError on legacy logs.
for log in [
sync_log,
SimplifiedSyncLog.from_other_format(sync_log)
]:
log.update_phone_lists(xform, [parent_case])
self.assertIn(dependent_case_state,
log.test_only_get_dependent_cases_on_phone())
def test_extract_form_attachment_info(self):
image_1_name = "1234.jpg"
image_2_name = "5678.jpg"
form = {
"name": "foo",
"color": "bar",
"image_1": image_1_name,
"my_group": {
"image_2": image_2_name
}
}
with mock.patch.object(XFormInstanceSQL, 'form_data') as form_data_mock:
form_data_mock.__get__ = mock.MagicMock(return_value=form)
couch_xform = XFormInstance(
received_on=datetime.datetime.now(),
form=form,
_attachments={
image_1_name: {
"content_type": "image/jpeg",
"length": 1024,
},
image_2_name: {
"content_type": "image/jpeg",
"length": 2048,
},
"form.xml": {
"content_type": "text/xml",
"length": 2048,
}
}
)
sql_xform = XFormInstanceSQL(
received_on=datetime.datetime.now(),
)
sql_xform.unsaved_attachments = [
XFormAttachmentSQL(
name=image_1_name,
content_type="image/jpeg",
content_length=1024,
),
XFormAttachmentSQL(
name=image_2_name,
content_type="image/jpeg",
content_length=1024,
),
XFormAttachmentSQL(
name="form.xml",
content_type="text/xml",
content_length=1024,
),
]
for xform in (couch_xform, sql_xform):
form_info = _extract_form_attachment_info(xform, {"my_group-image_2", "image_1"})
attachments = {a['name']: a for a in form_info['attachments']}
self.assertTrue(image_1_name in attachments)
self.assertTrue(image_2_name in attachments)
self.assertEqual(attachments[image_1_name]['question_id'], "image_1")
self.assertEqual(attachments[image_2_name]['question_id'], "my_group-image_2")
def _valid_measles_form(received_on):
return XFormInstance(
form={'child_1': {
'child1_child_measlesvacc': '1',
}},
received_on=received_on,
xmlns=CFU1_XMLNS,
)
def _child_form_without_vhnd_attendance(received_on, xmlns=CFU1_XMLNS):
return XFormInstance(
received_on=received_on,
xmlns=xmlns,
form={'child_1': {
'child1_attendance_vhnd': '0'
}},
)
def _valid_child_weight_registration_form(received_on):
return XFormInstance(
form={'child_1': {
'child1_child_weight': '1',
}},
received_on=received_on,
xmlns=CFU1_XMLNS,
)
def new_form(domain=DOMAIN, app_id=DEFAULT_APP_ID, xmlns=DEFAULT_XMLNS, **kwargs):
kwargs["_id"] = kwargs.get("_id", uuid.uuid4().hex)
return XFormInstance(
domain=domain,
app_id=app_id,
xmlns=xmlns,
**kwargs
)
def test_mock_data(self):
report = Report(month=6, year=2014, block="Atri")
form = XFormInstance(form={'foo': 'bar'}, received_on=datetime(2014, 6, 15))
case = OPMCase(
forms=[form],
# add/override any desired case properties here
edd=date(2014, 11, 10),
)
row = MockCaseRow(case, report)
def saving(request):
xform = XFormInstance(_attachments={'form.xml': {'data': '-'}})
xform.save()
case = CommCareCase()
case.save()
xform.initial_processing_complete = True
xform.save()
case.delete()
xform.delete()
return HttpResponse('Thanks for submitting', status=201)
def setUp(self):
self.domain = self._get_name_for_domain()
self.form = XFormInstance(domain=self.domain)
self.form.save()
self.new_stock_report = NewStockReport(
self.form,
datetime.now(),
REPORT_TYPE_BALANCE,
[],
)
def create_report(self, transactions=None, tag=None, date=None):
form = XFormInstance(domain=self.domain)
form.save()
report = StockReportHelper(
form,
date or datetime.utcnow(),
tag or REPORT_TYPE_BALANCE,
transactions or [],
)
return report, form
def setUpClass(cls):
super(ExportsFormsAnalyticsTest, cls).setUpClass()
from casexml.apps.case.tests.util import delete_all_xforms
from corehq.apps.app_manager.models import Application, Module, Form
delete_all_xforms()
with trap_extra_setup(ConnectionError,
msg="cannot connect to elasicsearch"):
cls.es = get_es_new()
initialize_index_and_mapping(cls.es, XFORM_INDEX_INFO)
cls.domain = 'exports_forms_analytics_domain'
cls.app_id_1 = 'a' + uuid.uuid4().hex
cls.app_id_2 = 'b' + uuid.uuid4().hex
cls.xmlns_1 = 'my://crazy.xmlns/'
cls.xmlns_2 = 'my://crazy.xmlns/app'
cls.apps = [
Application(_id=cls.app_id_2,
domain=cls.domain,
modules=[Module(forms=[Form(xmlns=cls.xmlns_2)])])
]
for app in cls.apps:
app.save()
cls.forms = [
XFormInstance(domain=cls.domain,
app_id=cls.app_id_1,
xmlns=cls.xmlns_1),
XFormInstance(domain=cls.domain,
app_id=cls.app_id_1,
xmlns=cls.xmlns_1),
XFormInstance(domain=cls.domain,
app_id=cls.app_id_2,
xmlns=cls.xmlns_2),
]
cls.error_forms = [XFormError(domain=cls.domain)]
cls.all_forms = cls.forms + cls.error_forms
for form in cls.all_forms:
form.save()
send_to_elasticsearch('forms', form.to_json())
cls.es.indices.refresh(XFORM_INDEX_INFO.index)
update_analytics_indexes()
def test_get_docs_in_domain_by_class(self):
commtrack_config = CommtrackConfig(domain=self.domain)
group = Group(domain=self.domain)
xform = XFormInstance(domain=self.domain)
commtrack_config.save()
group.save()
xform.save()
self.addCleanup(commtrack_config.delete)
self.addCleanup(group.delete)
self.addCleanup(xform.delete)
[commtrack_config_2] = get_docs_in_domain_by_class(self.domain, CommtrackConfig)
self.assertEqual(commtrack_config_2.to_json(), commtrack_config.to_json())
def test_couch_filter(self):
pillow = _make_couch_pillow(self.couch_db)
pillow.couch_filter = 'couchforms/xforms'
# save a random doc, then a form-looking thing
self.couch_db.save_doc({'_id': uuid.uuid4().hex, 'property': 'property_value'})
form = XFormInstance(domain='test-domain')
form.save()
pillow.process_changes(since=self.update_seq, forever=False)
change = self._extract_change_from_call_args(pillow.process_change.call_args)
self.assertEqual(form._id, change['id'])
self.assertEqual(form.domain, change['doc']['domain'])
def test_get_doc_ids_in_domain_by_class(self):
user_role = UserRole(domain=self.domain)
group = Group(domain=self.domain)
xform = XFormInstance(domain=self.domain)
user_role.save()
group.save()
xform.save()
self.addCleanup(user_role.delete)
self.addCleanup(group.delete)
self.addCleanup(xform.delete)
[doc_id] = get_doc_ids_in_domain_by_class(self.domain, UserRole)
self.assertEqual(doc_id, user_role.get_id)
def new_xform(cls, form_data):
_id = extract_meta_instance_id(form_data) or uuid.uuid4().hex
assert _id
xform = XFormInstance(
# form has to be wrapped
{'form': form_data},
# other properties can be set post-wrap
_id=_id,
xmlns=form_data.get('@xmlns'),
received_on=datetime.datetime.utcnow(),
)
return xform
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_get_list(self):
"""
Any form in the appropriate domain should be in the list from the API.
"""
# The actual infrastructure involves saving to CouchDB, having PillowTop
# read the changes and write it to ElasticSearch.
# In order to test just the API code, we set up a fake XFormES (this should
# really be a parameter to the XFormInstanceResource constructor)
# and write the translated form directly; we are not trying to test
# the ptop infrastructure.
# the pillow is set to offline mode - elasticsearch not needed to validate
fake_xform_es = FakeXFormES()
v0_4.MOCK_XFORM_ES = fake_xform_es
backend_form = XFormInstance(
xmlns='fake-xmlns',
domain=self.domain.name,
received_on=datetime.utcnow(),
edited_on=datetime.utcnow(),
form={
'#type': 'fake-type',
'@xmlns': 'fake-xmlns',
'meta': {
'userID': 'metadata-user-id'
},
},
auth_context={
'user_id': 'auth-user-id',
'domain': self.domain.name,
'authenticated': True,
},
)
backend_form.save()
self.addCleanup(backend_form.delete)
translated_doc = transform_xform_for_elasticsearch(
backend_form.to_json())
fake_xform_es.add_doc(translated_doc['_id'], translated_doc)
response = self._assert_auth_get_resource(self.list_endpoint)
self.assertEqual(response.status_code, 200)
api_forms = json.loads(response.content)['objects']
self.assertEqual(len(api_forms), 1)
api_form = api_forms[0]
self.assertEqual(api_form['form']['@xmlns'], backend_form.xmlns)
self.assertEqual(api_form['received_on'],
json_format_datetime(backend_form.received_on))
self.assertEqual(api_form['metadata']['userID'], 'metadata-user-id')
self.assertEqual(api_form['edited_by_user_id'], 'auth-user-id')
def M4ChangeFormFluffPillow(delete_filtered=False):
return get_multi_fluff_pillow(indicator_classes=[
AncHmisCaseFluff,
LdHmisCaseFluff,
ImmunizationHmisCaseFluff,
ProjectIndicatorsCaseFluff,
McctMonthlyAggregateFormFluff,
AllHmisCaseFluff,
],
name='M4ChangeFormFluff',
kafka_topic=get_topic_for_doc_type(
XFormInstance().to_json()['doc_type']),
delete_filtered=delete_filtered)
