def test_simple_invalid(self):
self.assertEqual(
validate_xpath('data node'),
XpathValidationResponse(is_valid=False, message=
b"""Lexical error on line 1. Unrecognized text.
data node
-----^
"""))
def test_real_invalid(self):
self.assertEqual(
validate_xpath(
"if(count(instance('commcaresession')/session/user/data/commcare_location_id) > 0, instance('commcaresession')/session/user/data/commcare_location_id, /data/meta/userID)"),
XpathValidationResponse(is_valid=False, message=
b"""Lexical error on line 1. Unrecognized text.
...mmcare_location_id) > 0, instance('co
-----------------------^
"""))
def test_simple_invalid(self):
self.assertEqual(
validate_xpath('data node'),
XpathValidationResponse(
is_valid=False,
message=b"""Lexical error on line 1. Unrecognized text.
data node
-----^
"""))
def test_real_invalid(self):
self.assertEqual(
validate_xpath(
"if(count(instance('commcaresession')/session/user/data/commcare_location_id) > 0, instance('commcaresession')/session/user/data/commcare_location_id, /data/meta/userID)"
),
XpathValidationResponse(
is_valid=False,
message=b"""Lexical error on line 1. Unrecognized text.
...mmcare_location_id) > 0, instance('co
-----------------------^
"""))
def validate_with_raise(self):
'''
This is the real validation logic, to be overridden/augmented by subclasses.
'''
errors = []
needs_case_detail = self.module.requires_case_details()
needs_case_type = needs_case_detail or any(
f.is_registration_form() for f in self.module.get_forms())
if needs_case_detail or needs_case_type:
errors.extend(
self.module.validator.get_case_errors(
needs_case_type=needs_case_type,
needs_case_detail=needs_case_detail))
if self.module.case_list_form.form_id:
try:
form = self.module.get_app().get_form(
self.module.case_list_form.form_id)
except FormNotFoundException:
errors.append({
'type': 'case list form missing',
'module': self.get_module_info()
})
else:
if not form.is_registration_form(self.module.case_type):
errors.append({
'type': 'case list form not registration',
'module': self.get_module_info(),
'form': form,
})
if self.module.module_filter:
is_valid, message = validate_xpath(self.module.module_filter)
if not is_valid:
errors.append({
'type': 'module filter has xpath error',
'xpath_error': message,
'module': self.get_module_info(),
})
return errors
def validate_with_raise(self):
'''
This is the real validation logic, to be overridden/augmented by subclasses.
'''
errors = []
needs_case_detail = self.module.requires_case_details()
needs_case_type = needs_case_detail or any(f.is_registration_form() for f in self.module.get_forms())
if needs_case_detail or needs_case_type:
errors.extend(self.module.validator.get_case_errors(
needs_case_type=needs_case_type,
needs_case_detail=needs_case_detail
))
if self.module.case_list_form.form_id:
try:
form = self.module.get_app().get_form(self.module.case_list_form.form_id)
except FormNotFoundException:
errors.append({
'type': 'case list form missing',
'module': self.get_module_info()
})
else:
if not form.is_registration_form(self.module.case_type):
errors.append({
'type': 'case list form not registration',
'module': self.get_module_info(),
'form': form,
})
if self.module.module_filter:
is_valid, message = validate_xpath(self.module.module_filter)
if not is_valid:
errors.append({
'type': 'module filter has xpath error',
'xpath_error': message,
'module': self.get_module_info(),
})
return errors
def test_good_hashtag(self):
self.assertEqual(validate_xpath('#session'),
XpathValidationResponse(is_valid=True, message=None))
def test_real_valid(self):
self.assertEqual(
validate_xpath(
"if(count(instance('commcaresession')/session/user/data/commcare_location_id) > 0, instance('commcaresession')/session/user/data/commcare_location_id, /data/meta/userID)"
), XpathValidationResponse(is_valid=True, message=None))
def test_disallowed_case_hashtag(self):
self.assertEqual(
validate_xpath('#case', allow_case_hashtags=False),
XpathValidationResponse(
is_valid=False, message=b"case is not a valid # expression\n"))
def test_disallowed_case_hashtag(self):
self.assertEqual(
validate_xpath('#case', allow_case_hashtags=False),
XpathValidationResponse(is_valid=False,
message=b"case is not a valid # expression\n"))
def test_case_hashtag(self):
self.assertEqual(
validate_xpath('#case', allow_case_hashtags=True),
XpathValidationResponse(is_valid=True, message=None))
def test_bad_hashtag(self):
self.assertEqual(
validate_xpath('#hashtag'),
XpathValidationResponse(is_valid=False,
message=b"hashtag is not a valid # expression\n"))
def test_good_hashtag(self):
self.assertEqual(
validate_xpath('#session'),
XpathValidationResponse(is_valid=True, message=None))
def test_real_valid(self):
self.assertEqual(
validate_xpath(
"if(count(instance('commcaresession')/session/user/data/commcare_location_id) > 0, instance('commcaresession')/session/user/data/commcare_location_id, /data/meta/userID)"),
XpathValidationResponse(is_valid=True, message=None))
def test_bad_hashtag(self):
self.assertEqual(
validate_xpath('#hashtag'),
XpathValidationResponse(
is_valid=False,
message=b"hashtag is not a valid # expression\n"))
def test_case_hashtag(self):
self.assertEqual(validate_xpath('#case', allow_case_hashtags=True),
XpathValidationResponse(is_valid=True, message=None))
def test_simple_valid(self):
self.assertEqual(
validate_xpath('/data/node'),
XpathValidationResponse(is_valid=True, message=None))
def test_simple_valid(self):
self.assertEqual(validate_xpath('/data/node'),
XpathValidationResponse(is_valid=True, message=None))
def test_whitespace(self):
self.assertEqual(validate_xpath('\n1 =\t2\r + 3'),
XpathValidationResponse(is_valid=True, message=None))
def validate_for_build(self, validate_module):
errors = []
try:
module = self.form.get_module()
except AttributeError:
module = None
meta = {
'form_type': self.form.form_type,
'module': module.validator.get_module_info() if module else {},
'form': {
"id": self.form.id if hasattr(self.form, 'id') else None,
"name": self.form.name,
'unique_id': self.form.unique_id,
}
}
xml_valid = False
if self.form.source == '' and self.form.form_type != 'shadow_form':
errors.append(dict(type="blank form", **meta))
else:
try:
_parse_xml(self.form.source)
xml_valid = True
except XFormException as e:
errors.append(dict(
type="invalid xml",
message=six.text_type(e) if self.form.source else '',
**meta
))
except ValueError:
logging.error("Failed: _parse_xml(string=%r)" % self.form.source)
raise
try:
questions = self.form.cached_get_questions()
except XFormException as e:
error = {'type': 'validation error', 'validation_message': six.text_type(e)}
error.update(meta)
errors.append(error)
if not errors:
has_questions = any(not q.get('is_group') for q in questions)
if not has_questions and self.form.form_type != 'shadow_form':
errors.append(dict(type="blank form", **meta))
else:
try:
self.form.validate_form()
except XFormValidationError as e:
error = {'type': 'validation error', 'validation_message': six.text_type(e)}
error.update(meta)
errors.append(error)
except XFormValidationFailed:
pass # ignore this here as it gets picked up in other places
if self.form.post_form_workflow == WORKFLOW_FORM:
if not self.form.form_links:
errors.append(dict(type="no form links", **meta))
for form_link in self.form.form_links:
try:
self.form.get_app().get_form(form_link.form_id)
except FormNotFoundException:
errors.append(dict(type='bad form link', **meta))
elif self.form.post_form_workflow == WORKFLOW_PARENT_MODULE:
if not module.root_module:
errors.append(dict(type='form link to missing root', **meta))
# this isn't great but two of FormBase's subclasses have form_filter
if hasattr(self.form, 'form_filter') and self.form.form_filter:
with self.form.timing_context("validate_xpath"):
is_valid, message = validate_xpath(self.form.form_filter, allow_case_hashtags=True)
if not is_valid:
error = {
'type': 'form filter has xpath error',
'xpath_error': message,
}
error.update(meta)
errors.append(error)
errors.extend(self.extended_build_validation(meta, xml_valid, validate_module))
return errors
def test_unicode(self):
self.assertEqual(validate_xpath('"Serviços e Supervisão"'),
XpathValidationResponse(is_valid=True, message=None))
def validate_for_build(self, validate_module):
errors = []
try:
module = self.form.get_module()
except AttributeError:
module = None
meta = {
'form_type': self.form.form_type,
'module': module.validator.get_module_info() if module else {},
'form': {
"id": self.form.id if hasattr(self.form, 'id') else None,
"name": self.form.name,
'unique_id': self.form.unique_id,
}
}
xml_valid = False
if self.form.source == '' and self.form.form_type != 'shadow_form':
errors.append(dict(type="blank form", **meta))
else:
try:
_parse_xml(self.form.source)
xml_valid = True
except XFormException as e:
errors.append(dict(
type="invalid xml",
message=str(e) if self.form.source else '',
**meta
))
except ValueError:
logging.error("Failed: _parse_xml(string=%r)" % self.form.source)
raise
try:
questions = self.form.cached_get_questions()
except XFormException as e:
error = {'type': 'validation error', 'validation_message': str(e)}
error.update(meta)
errors.append(error)
if not errors:
has_questions = any(not q.get('is_group') for q in questions)
if not has_questions and self.form.form_type != 'shadow_form':
errors.append(dict(type="blank form", **meta))
else:
try:
self.form.validate_form()
except XFormValidationError as e:
error = {'type': 'validation error', 'validation_message': str(e)}
error.update(meta)
errors.append(error)
except XFormValidationFailed:
pass # ignore this here as it gets picked up in other places
if self.form.post_form_workflow == WORKFLOW_FORM:
if not self.form.form_links:
errors.append(dict(type="no form links", **meta))
for form_link in self.form.form_links:
try:
self.form.get_app().get_form(form_link.form_id)
except FormNotFoundException:
errors.append(dict(type='bad form link', **meta))
elif self.form.post_form_workflow == WORKFLOW_MODULE:
if module.put_in_root:
errors.append(dict(type='form link to display only forms', **meta))
elif self.form.post_form_workflow == WORKFLOW_PARENT_MODULE:
if not module.root_module:
errors.append(dict(type='form link to missing root', **meta))
if module.root_module.put_in_root:
errors.append(dict(type='form link to display only forms', **meta))
# this isn't great but two of FormBase's subclasses have form_filter
if hasattr(self.form, 'form_filter') and self.form.form_filter:
with self.form.timing_context("validate_xpath"):
is_valid, message = validate_xpath(self.form.form_filter, allow_case_hashtags=True)
if not is_valid:
error = {
'type': 'form filter has xpath error',
'xpath_error': message,
}
error.update(meta)
errors.append(error)
errors.extend(self.extended_build_validation(meta, xml_valid, validate_module))
return errors
def validate_with_raise(self):
'''
This is the real validation logic, to be overridden/augmented by subclasses.
'''
errors = []
app = self.module.get_app()
needs_case_detail = self.module.requires_case_details()
needs_case_type = needs_case_detail or any(
f.is_registration_form() for f in self.module.get_forms())
if needs_case_detail or needs_case_type:
errors.extend(
self.module.validator.get_case_errors(
needs_case_type=needs_case_type,
needs_case_detail=needs_case_detail))
if self.module.case_list_form.form_id:
try:
form = app.get_form(self.module.case_list_form.form_id)
except FormNotFoundException:
errors.append({
'type': 'case list form missing',
'module': self.get_module_info()
})
else:
if toggles.FOLLOWUP_FORMS_AS_CASE_LIST_FORM.enabled(
app.domain):
from corehq.apps.app_manager.views.modules import get_parent_select_followup_forms
valid_forms = [
f.unique_id for f in get_parent_select_followup_forms(
app, self.module)
]
if form.unique_id not in valid_forms and not form.is_registration_form(
self.module.case_type):
errors.append({
'type': 'invalid case list followup form',
'module': self.get_module_info(),
'form': form,
})
elif not form.is_registration_form(self.module.case_type):
errors.append({
'type': 'case list form not registration',
'module': self.get_module_info(),
'form': form,
})
if self.module.module_filter:
is_valid, message = validate_xpath(self.module.module_filter)
if not is_valid:
errors.append({
'type': 'module filter has xpath error',
'xpath_error': message,
'module': self.get_module_info(),
})
if self.module.put_in_root and self.module.session_endpoint_id:
errors.append({
'type': 'endpoint to display only forms',
'module': self.get_module_info(),
})
if hasattr(self.module,
'parent_select') and self.module.parent_select.active:
if self.module.parent_select.relationship == 'parent':
from corehq.apps.app_manager.views.modules import get_modules_with_parent_case_type
valid_modules = get_modules_with_parent_case_type(
app, self.module)
else:
from corehq.apps.app_manager.views.modules import get_all_case_modules
valid_modules = get_all_case_modules(app, self.module)
valid_module_ids = [info['unique_id'] for info in valid_modules]
if self.module.parent_select.module_id not in valid_module_ids:
errors.append({
'type': 'invalid parent select id',
'module': self.get_module_info(),
})
if module_uses_smart_links(self.module):
if not self.module.session_endpoint_id:
errors.append({
'type': 'smart links missing endpoint',
'module': self.get_module_info(),
})
if self.module.parent_select.active:
errors.append({
'type': 'smart links select parent first',
'module': self.get_module_info(),
})
if self.module.is_multi_select():
errors.append({
'type': 'smart links multi select',
'module': self.get_module_info(),
})
if module_loads_registry_case(self.module):
if self.module.is_multi_select():
errors.append({
'type': 'data registry multi select',
'module': self.get_module_info(),
})
return errors
