def validate(cls, text):
if not isinstance(text, six.string_types):
raise ValueError('Text to be evaluated is not typeof string.')
errors = []
# Validate the entire text to cover malformed delimiters and blocks.
try:
cls._jinja_env.parse(text)
except jinja2.exceptions.TemplateError as e:
errors.append(expr_util.format_error(cls._type, text, e))
# Validate individual inline expressions.
for expr in cls._regex_parser.findall(text):
# Skip expression if it has already been validated and erred.
if list(filter(lambda x: x['expression'] == expr, errors)):
continue
try:
parser = jinja2.parser.Parser(cls._jinja_env.overlay(),
cls.strip_delimiter(expr),
state='variable')
parser.parse_expression()
except jinja2.exceptions.TemplateError as e:
errors.append(expr_util.format_error(cls._type, expr, e))
return errors
def validate(statement):
errors = []
if isinstance(statement, dict):
for k, v in six.iteritems(statement):
errors.extend(validate(k)['errors'])
errors.extend(validate(v)['errors'])
elif isinstance(statement, list):
for item in statement:
errors.extend(validate(item)['errors'])
elif isinstance(statement, six.string_types):
evaluators = [
evaluator for name, evaluator in six.iteritems(get_evaluators())
if evaluator.has_expressions(statement)
]
if len(evaluators) == 1:
errors.extend(evaluators[0].validate(statement))
elif len(evaluators) > 1:
message = 'Expression with multiple types is not supported.'
errors.append(expr_util.format_error(None, statement, message))
return {'errors': errors}
def decorate_ctx_var_error(var):
error = expr_utils.format_error(
var['type'], var['expression'],
'Variable "%s" is referenced before assignment.' % var['name'],
var['spec_path'], var['schema_path'])
return error
def test_format_error_str(self):
expected = {
'type': 'yaql',
'expression': '$.foo in $.bar',
'message': 'Unknown error.'
}
actual = utils.format_error('yaql', '$.foo in $.bar', 'Unknown error.')
self.assertEqual(expected, actual)
def test_format_error(self):
expected = {
'type': 'yaql',
'expression': '$.foo in $.bar',
'message': 'Unknown error.'
}
actual = expr_util.format_error('yaql', '$.foo in $.bar',
Exception('Unknown error.'))
self.assertEqual(expected, actual)
def test_format_error_str(self):
expected = {
"type": "yaql",
"expression": "$.foo in $.bar",
"message": "Unknown error."
}
actual = expr_util.format_error("yaql", "$.foo in $.bar",
"Unknown error.")
self.assertEqual(expected, actual)
def validate(cls, text):
if not isinstance(text, six.string_types):
raise ValueError('Text to be evaluated is not typeof string.')
errors = []
for expr in cls._regex_parser.findall(text):
try:
cls._engine(cls.strip_delimiter(expr))
except (yaql_exc.YaqlException, ValueError, TypeError) as e:
errors.append(expr_util.format_error(cls._type, expr, e))
return errors
def test_format_error_with_paths(self):
expected = {
'type': 'yaql',
'expression': '$.foo in $.bar',
'spec_path': 'path.to.error.in.spec',
'schema_path': 'path.to.reference.in.schema',
'message': 'Unknown error.'
}
actual = utils.format_error('yaql',
'$.foo in $.bar',
Exception('Unknown error.'),
spec_path='path.to.error.in.spec',
schema_path='path.to.reference.in.schema')
self.assertEqual(expected, actual)
def test_format_error_with_paths(self):
expected = {
"type": "yaql",
"expression": "$.foo in $.bar",
"spec_path": "path.to.error.in.spec",
"schema_path": "path.to.reference.in.schema",
"message": "Unknown error.",
}
actual = expr_util.format_error(
"yaql",
"$.foo in $.bar",
Exception("Unknown error."),
spec_path="path.to.error.in.spec",
schema_path="path.to.reference.in.schema",
)
self.assertEqual(expected, actual)
def decorate_ctx_var_error(var, msg):
error = expr_util.format_error(
var["type"], var["expression"], msg, var["spec_path"], var["schema_path"]
)
return error
def decorate_ctx_var_error(var, msg):
error = expr_util.format_error(var['type'], var['expression'], msg,
var['spec_path'],
var['schema_path'])
return error
