def worker():
p = parser.Parser()
for expression in expressions:
try:
p.parse(expression)
except Exception as e:
errors.append(e)
def test_cache_purge(self):
p = parser.Parser()
first = p.parse('foo')
cached = p.parse('foo')
p.purge()
second = p.parse('foo')
self.assertEqual(first.parsed, second.parsed)
self.assertEqual(first.parsed, cached.parsed)
def test_can_have_ordered_dict(self):
p = parser.Parser()
parsed = p.parse('{a: a, b: b, c: c}')
options = visitor.Options(dict_cls=OrderedDict)
result = parsed.search({"c": "c", "b": "b", "a": "a"}, options=options)
# The order should be 'a', 'b' because we're using an
# OrderedDict
self.assertEqual(list(result), ['a', 'b', 'c'])
def test_cache_purge(self):
p = parser.Parser()
first = p.parse('foo')
cached = p.parse('foo')
p.purge()
second = p.parse('foo')
self.assertEqual(as_s_expression(first.parsed),
as_s_expression(second.parsed))
self.assertEqual(as_s_expression(first.parsed),
as_s_expression(cached.parsed))
def test_dot_file_subexpr(self):
p = parser.Parser()
result = p.parse('foo.bar')
dot_contents = result._render_dot_file()
self.assertEqual(
dot_contents, 'digraph AST {\n'
'subexpression1 [label="subexpression()"]\n'
' subexpression1 -> field2\n'
'field2 [label="field(foo)"]\n'
' subexpression1 -> field3\n'
'field3 [label="field(bar)"]\n}')
def test_search_api(expr, data):
try:
ast = parser.Parser().parse(expr)
except exceptions.JMESPathError as e:
# We want to try to parse things that tokenize
# properly.
assume(False)
try:
ast.search(data)
except exceptions.JMESPathError as e:
return
except Exception as e:
raise AssertionError("Non JMESPathError raised: %s" % e)
def test_parser_api_from_str(expr):
# Same a lexer above with the assumption that we're parsing
# a valid sequence of tokens.
try:
list(lexer.Lexer().tokenize(expr))
except exceptions.JMESPathError as e:
# We want to try to parse things that tokenize
# properly.
assume(False)
try:
ast = parser.Parser().parse(expr)
except exceptions.JMESPathError as e:
return
except Exception as e:
raise AssertionError("Non JMESPathError raised: %s" % e)
assert isinstance(ast.parsed, dict)
def test_compile_lots_of_expressions(self):
# We have to be careful here because this is an implementation detail
# that should be abstracted from the user, but we need to make sure we
# exercise the code and that it doesn't blow up.
p = parser.Parser()
compiled = []
compiled2 = []
for i in range(parser.Parser._MAX_SIZE + 1):
compiled.append(p.parse('foo%s' % i))
# Rerun the test and half of these entries should be from the
# cache but they should still be equal to compiled.
for i in range(parser.Parser._MAX_SIZE + 1):
compiled2.append(p.parse('foo%s' % i))
self.assertEqual(len(compiled), len(compiled2))
self.assertEqual([expr.parsed for expr in compiled],
[expr.parsed for expr in compiled2])
def setUp(self):
self.parser = parser.Parser()
self.data = {
'foo': [
{
'bar': [{
'baz': 'one'
}, {
'baz': 'two'
}]
},
{
'bar': [{
'baz': 'three'
}, {
'baz': 'four'
}, {
'baz': 'five'
}]
},
]
}
def compile(expression):
return parser.Parser().parse(expression)
def search(expression, data, options=None):
return parser.Parser().parse(expression).search(data, options=options)
def compile(expression, debug=False):
return parser.Parser(debug=debug).parse(expression)
def search(expression, data, debug=False):
return parser.Parser(debug=debug).parse(expression).search(data)
def test_dot_file_rendered(self):
p = parser.Parser()
result = p.parse('foo')
dot_contents = result._render_dot_file()
self.assertEqual(dot_contents,
'digraph AST {\nfield1 [label="field(foo)"]\n}')
def search(expression, data):
return parser.Parser().parse(expression).search(data)
def test_expression_available_from_parser(self):
p = parser.Parser()
parsed = p.parse('foo.bar')
self.assertEqual(parsed.expression, 'foo.bar')
def setUp(self):
self.parser = parser.Parser()
def setUp(self):
self.parser = parser.Parser()
self.data = {
"foo": [[["one", "two"], ["three", "four"]],
[["five", "six"], ["seven", "eight"]], [["nine"], ["ten"]]]
}
