def test_error_getitem_undefined_string(self):
class Something(object):
def __repr__(self):
return '<Something>'
expr = Expression('something["nil"]',
filename='index.html',
lineno=50,
lookup='strict')
try:
expr.evaluate({'something': Something()})
self.fail('Expected UndefinedError')
except UndefinedError, e:
self.assertEqual('<Something> has no member named "nil"', str(e))
exc_type, exc_value, exc_traceback = sys.exc_info()
search_string = '''<Expression 'something["nil"]'>'''
frame = exc_traceback.tb_next
while frame.tb_next:
frame = frame.tb_next
code = frame.tb_frame.f_code
if code.co_name == search_string:
break
else:
self.fail("never found the frame I was looking for")
self.assertEqual('index.html', code.co_filename)
self.assertEqual(50, frame.tb_lineno)
def test_str_literal_non_ascii(self):
expr = Expression(u"u'\xfe'")
self.assertEqual(u'þ', expr.evaluate({}))
expr = Expression("u'\xfe'")
self.assertEqual(u'þ', expr.evaluate({}))
expr = Expression("'\xc3\xbe'")
self.assertEqual(u'þ', expr.evaluate({}))
def test_list_comprehension(self):
expr = Expression("[n for n in numbers if n < 2]")
self.assertEqual([0, 1], expr.evaluate({'numbers': list(range(5))}))
expr = Expression("[(i, n + 1) for i, n in enumerate(numbers)]")
self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
expr.evaluate({'numbers': list(range(5))}))
expr = Expression("[offset + n for n in numbers]")
self.assertEqual([2, 3, 4, 5, 6],
expr.evaluate({
'numbers': list(range(5)),
'offset': 2
}))
expr = Expression("[n for group in groups for n in group]")
self.assertEqual([0, 1, 0, 1, 2],
expr.evaluate(
{'groups': [list(range(2)),
list(range(3))]}))
expr = Expression("[(a, b) for a in x for b in y]")
self.assertEqual([('x0', 'y0'), ('x0', 'y1'), ('x1', 'y0'),
('x1', 'y1')],
expr.evaluate({
'x': ['x0', 'x1'],
'y': ['y0', 'y1']
}))
def test_str_literal_non_ascii(self):
expr = Expression(u"u'\xfe'")
self.assertEqual(u'þ', expr.evaluate({}))
expr = Expression("u'\xfe'")
self.assertEqual(u'þ', expr.evaluate({}))
expr = Expression("'\xc3\xbe'")
self.assertEqual(u'þ', expr.evaluate({}))
def test_generator_expression(self):
expr = Expression("list(n for n in numbers if n < 2)")
self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
expr = Expression("list((i, n + 1) for i, n in enumerate(numbers))")
self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
expr.evaluate({'numbers': range(5)}))
expr = Expression("list(offset + n for n in numbers)")
self.assertEqual([2, 3, 4, 5, 6],
expr.evaluate({
'numbers': range(5),
'offset': 2
}))
expr = Expression("list(n for group in groups for n in group)")
self.assertEqual([0, 1, 0, 1, 2],
expr.evaluate({'groups': [range(2),
range(3)]}))
expr = Expression("list((a, b) for a in x for b in y)")
self.assertEqual([('x0', 'y0'), ('x0', 'y1'), ('x1', 'y0'),
('x1', 'y1')],
expr.evaluate({
'x': ['x0', 'x1'],
'y': ['y0', 'y1']
}))
def test_generator_expression(self):
expr = Expression("list(n for n in numbers if n < 2)")
self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
expr = Expression("list((i, n + 1) for i, n in enumerate(numbers))")
self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
expr.evaluate({'numbers': range(5)}))
expr = Expression("list(offset + n for n in numbers)")
self.assertEqual([2, 3, 4, 5, 6],
expr.evaluate({'numbers': range(5), 'offset': 2}))
def test_list_comprehension(self):
expr = Expression("[n for n in numbers if n < 2]")
self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
expr = Expression("[(i, n + 1) for i, n in enumerate(numbers)]")
self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
expr.evaluate({'numbers': range(5)}))
expr = Expression("[offset + n for n in numbers]")
self.assertEqual([2, 3, 4, 5, 6],
expr.evaluate({'numbers': range(5), 'offset': 2}))
def test_list_comprehension(self):
expr = Expression("[n for n in numbers if n < 2]")
self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
expr = Expression("[(i, n + 1) for i, n in enumerate(numbers)]")
self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
expr.evaluate({'numbers': range(5)}))
expr = Expression("[offset + n for n in numbers]")
self.assertEqual([2, 3, 4, 5, 6],
expr.evaluate({
'numbers': range(5),
'offset': 2
}))
def test_str_literal_non_ascii(self):
expr = Expression(u"u'\xfe'")
self.assertEqual(u'þ', expr.evaluate({}))
expr = Expression("u'\xfe'")
self.assertEqual(u'þ', expr.evaluate({}))
# On Python2 strings are converted to unicode if they contained
# non-ASCII characters.
# On Py3k, we have no need to do this as non-prefixed strings aren't
# raw.
expr = Expression(wrapped_bytes(r"b'\xc3\xbe'"))
if IS_PYTHON2:
self.assertEqual(u'þ', expr.evaluate({}))
else:
self.assertEqual(u'þ'.encode('utf-8'), expr.evaluate({}))
def test_generator_expression(self):
expr = Expression("list(n for n in numbers if n < 2)")
self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
expr = Expression("list((i, n + 1) for i, n in enumerate(numbers))")
self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
expr.evaluate({'numbers': range(5)}))
expr = Expression("list(offset + n for n in numbers)")
self.assertEqual([2, 3, 4, 5, 6],
expr.evaluate({
'numbers': range(5),
'offset': 2
}))
def test_str_literal_non_ascii(self):
expr = Expression(u"u'\xfe'")
self.assertEqual(u'þ', expr.evaluate({}))
expr = Expression("u'\xfe'")
self.assertEqual(u'þ', expr.evaluate({}))
# On Python2 strings are converted to unicode if they contained
# non-ASCII characters.
# On Py3k, we have no need to do this as non-prefixed strings aren't
# raw.
expr = Expression(wrapped_bytes(r"b'\xc3\xbe'"))
if IS_PYTHON2:
self.assertEqual(u'þ', expr.evaluate({}))
else:
self.assertEqual(u'þ'.encode('utf-8'), expr.evaluate({}))
def test_lambda(self):
# Define a custom `sorted` function cause the builtin isn't available
# on Python 2.3
def sorted(items, compfunc):
items.sort(compfunc)
return items
data = {
'items': [{
'name': 'b',
'value': 0
}, {
'name': 'a',
'value': 1
}],
'sorted': sorted
}
expr = Expression("sorted(items, lambda a, b: cmp(a.name, b.name))")
self.assertEqual([{
'name': 'a',
'value': 1
}, {
'name': 'b',
'value': 0
}], expr.evaluate(data))
def test_lambda_tuple_arg(self):
# This syntax goes away in Python 3
if not IS_PYTHON2:
return
data = {'items': [(1, 2), (2, 1)]}
expr = Expression("filter(lambda (x, y): x > y, items)")
self.assertEqual([(2, 1)], list(expr.evaluate(data)))
def test_access_undefined(self):
expr = Expression("nothing", filename='index.html', lineno=50,
lookup='lenient')
retval = expr.evaluate({})
assert isinstance(retval, Undefined)
self.assertEqual('nothing', retval._name)
assert retval._owner is UNDEFINED
def test_slice_attribute(self):
class ValueHolder:
def __init__(self):
self.value = 3
expr = Expression("numbers[obj.value]")
res = expr.evaluate({"numbers": list(range(5)), "obj": ValueHolder()})
self.assertEqual(res, 3)
def test_slice_stride(self):
expr = Expression("numbers[::stride]")
self.assertEqual([0, 2, 4],
expr.evaluate({
'numbers': range(5),
'stride': 2
}))
def test_lambda_tuple_arg(self):
# This syntax goes away in Python 3
if not IS_PYTHON2:
return
data = {'items': [(1, 2), (2, 1)]}
expr = Expression("filter(lambda (x, y): x > y, items)")
self.assertEqual([(2, 1)], list(expr.evaluate(data)))
def test_access_undefined(self):
expr = Expression("nothing", filename='index.html', lineno=50,
lookup='lenient')
retval = expr.evaluate({})
assert isinstance(retval, Undefined)
self.assertEqual('nothing', retval._name)
assert retval._owner is UNDEFINED
def test_slice_call(self):
def f():
return 2
expr = Expression("numbers[f()]")
res = expr.evaluate({"numbers": list(range(5)), "f": f})
self.assertEqual(res, 2)
def test_slice_with_vars(self):
expr = Expression("numbers[start:end]")
self.assertEqual([0, 1],
expr.evaluate({
'numbers': range(5),
'start': 0,
'end': 2
}))
def test_error_access_undefined(self):
expr = Expression("nothing", filename='index.html', lineno=50,
lookup='strict')
try:
expr.evaluate({})
self.fail('Expected UndefinedError')
except UndefinedError as e:
exc_type, exc_value, exc_traceback = sys.exc_info()
frame = exc_traceback.tb_next
frames = []
while frame.tb_next:
frame = frame.tb_next
frames.append(frame)
self.assertEqual('"nothing" not defined', str(e))
self.assertEqual("<Expression 'nothing'>",
frames[-3].tb_frame.f_code.co_name)
self.assertEqual('index.html',
frames[-3].tb_frame.f_code.co_filename)
self.assertEqual(50, frames[-3].tb_lineno)
def test_list_comprehension(self):
expr = Expression("[n for n in numbers if n < 2]")
self.assertEqual([0, 1], expr.evaluate({'numbers': list(range(5))}))
expr = Expression("[(i, n + 1) for i, n in enumerate(numbers)]")
self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
expr.evaluate({'numbers': list(range(5))}))
expr = Expression("[offset + n for n in numbers]")
self.assertEqual([2, 3, 4, 5, 6],
expr.evaluate({'numbers': list(range(5)), 'offset': 2}))
expr = Expression("[n for group in groups for n in group]")
self.assertEqual([0, 1, 0, 1, 2],
expr.evaluate({'groups': [list(range(2)), list(range(3))]}))
expr = Expression("[(a, b) for a in x for b in y]")
self.assertEqual([('x0', 'y0'), ('x0', 'y1'), ('x1', 'y0'), ('x1', 'y1')],
expr.evaluate({'x': ['x0', 'x1'], 'y': ['y0', 'y1']}))
def test_generator_expression(self):
expr = Expression("list(n for n in numbers if n < 2)")
self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
expr = Expression("list((i, n + 1) for i, n in enumerate(numbers))")
self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
expr.evaluate({'numbers': range(5)}))
expr = Expression("list(offset + n for n in numbers)")
self.assertEqual([2, 3, 4, 5, 6],
expr.evaluate({'numbers': range(5), 'offset': 2}))
expr = Expression("list(n for group in groups for n in group)")
self.assertEqual([0, 1, 0, 1, 2],
expr.evaluate({'groups': [range(2), range(3)]}))
expr = Expression("list((a, b) for a in x for b in y)")
self.assertEqual([('x0', 'y0'), ('x0', 'y1'), ('x1', 'y0'), ('x1', 'y1')],
expr.evaluate({'x': ['x0', 'x1'], 'y': ['y0', 'y1']}))
def test_error_access_undefined(self):
expr = Expression("nothing", filename='index.html', lineno=50,
lookup='strict')
try:
expr.evaluate({})
self.fail('Expected UndefinedError')
except UndefinedError, e:
exc_type, exc_value, exc_traceback = sys.exc_info()
frame = exc_traceback.tb_next
frames = []
while frame.tb_next:
frame = frame.tb_next
frames.append(frame)
self.assertEqual('"nothing" not defined', str(e))
self.assertEqual("<Expression 'nothing'>",
frames[-3].tb_frame.f_code.co_name)
self.assertEqual('index.html',
frames[-3].tb_frame.f_code.co_filename)
self.assertEqual(50, frames[-3].tb_lineno)
def test_lambda(self):
# Define a custom `sorted` function cause the builtin isn't available
# on Python 2.3
def sorted(items, compfunc):
items.sort(compfunc)
return items
data = {'items': [{'name': 'b', 'value': 0}, {'name': 'a', 'value': 1}],
'sorted': sorted}
expr = Expression("sorted(items, lambda a, b: cmp(a.name, b.name))")
self.assertEqual([{'name': 'a', 'value': 1}, {'name': 'b', 'value': 0}],
expr.evaluate(data))
def test_getitem_undefined_string(self):
class Something(object):
def __repr__(self):
return '<Something>'
something = Something()
expr = Expression('something["nil"]', filename='index.html', lineno=50)
retval = expr.evaluate({'something': something})
assert isinstance(retval, Undefined)
self.assertEqual('nil', retval._name)
assert retval._owner is something
def test_getattr_undefined(self):
class Something(object):
def __repr__(self):
return '<Something>'
something = Something()
expr = Expression('something.nil', filename='index.html', lineno=50,
lookup='lenient')
retval = expr.evaluate({'something': something})
assert isinstance(retval, Undefined)
self.assertEqual('nil', retval._name)
assert retval._owner is something
def test_getitem_undefined_string(self):
class Something(object):
def __repr__(self):
return '<Something>'
something = Something()
expr = Expression('something["nil"]', filename='index.html', lineno=50,
lookup='lenient')
retval = expr.evaluate({'something': something})
assert isinstance(retval, Undefined)
self.assertEqual('nil', retval._name)
assert retval._owner is something
def test_error_getitem_undefined_string(self):
class Something(object):
def __repr__(self):
return '<Something>'
expr = Expression('something["nil"]', filename='index.html', lineno=50,
lookup='strict')
try:
expr.evaluate({'something': Something()})
self.fail('Expected UndefinedError')
except UndefinedError, e:
self.assertEqual('<Something> has no member named "nil"', str(e))
exc_type, exc_value, exc_traceback = sys.exc_info()
search_string = '''<Expression 'something["nil"]'>'''
frame = exc_traceback.tb_next
while frame.tb_next:
frame = frame.tb_next
code = frame.tb_frame.f_code
if code.co_name == search_string:
break
else:
self.fail("never found the frame I was looking for")
self.assertEqual('index.html', code.co_filename)
self.assertEqual(50, frame.tb_lineno)
def test_generator_expression_with_getitem(self):
items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
expr = Expression("list(i['name'] for i in items if i['value'] > 1)")
self.assertEqual(['b'], expr.evaluate({'items': items}))
def test_list_comprehension_with_getitem(self):
items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
expr = Expression("[i['name'] for i in items if i['value'] > 1]")
self.assertEqual(['b'], expr.evaluate({'items': items}))
def test_generator_expression_with_getitem(self):
items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
expr = Expression("list(i['name'] for i in items if i['value'] > 1)")
self.assertEqual(['b'], expr.evaluate({'items': items}))
def test_lambda(self):
data = {'items': range(5)}
expr = Expression("filter(lambda x: x > 2, items)")
self.assertEqual([3, 4], expr.evaluate(data))
def test_builtins(self):
expr = Expression('Markup')
self.assertEqual(expr.evaluate({}), Markup)
def test_slice_name(self):
expr = Expression("numbers[v]")
res = expr.evaluate({"numbers": list(range(5)), "v": 2})
self.assertEqual(res, 2)
def test_slice_stride(self):
expr = Expression("numbers[::stride]")
self.assertEqual([0, 2, 4], expr.evaluate({'numbers': range(5),
'stride': 2}))
def test_slice_negative_end(self):
expr = Expression("numbers[:-1]")
self.assertEqual([0, 1, 2, 3], expr.evaluate({'numbers': range(5)}))
def test_list_comprehension_with_getitem(self):
items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
expr = Expression("[i['name'] for i in items if i['value'] > 1]")
self.assertEqual(['b'], expr.evaluate({'items': items}))
def test_slice_with_vars(self):
expr = Expression("numbers[start:end]")
self.assertEqual([0, 1], expr.evaluate({'numbers': range(5), 'start': 0,
'end': 2}))
def test_slice_constant(self):
expr = Expression("numbers[1]")
res = expr.evaluate({"numbers": list(range(5))})
self.assertEqual(res, 1)
def test_call_dstar_args(self):
def foo(x):
return x
expr = Expression("foo(**bar)")
self.assertEqual(42, expr.evaluate({'foo': foo, 'bar': {"x": 42}}))
def test_slice_negative_end(self):
expr = Expression("numbers[:-1]")
self.assertEqual([0, 1, 2, 3], expr.evaluate({'numbers': range(5)}))
def test_slice_negative_start(self):
expr = Expression("numbers[-1:]")
self.assertEqual([4], expr.evaluate({'numbers': range(5)}))
def test_conditional_expression(self):
expr = Expression("'T' if foo else 'F'")
self.assertEqual('T', expr.evaluate({'foo': True}))
self.assertEqual('F', expr.evaluate({'foo': False}))
def test_lambda(self):
data = {'items': range(5)}
expr = Expression("filter(lambda x: x > 2, items)")
self.assertEqual([3, 4], expr.evaluate(data))
def test_slice(self):
expr = Expression("numbers[0:2]")
self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
def test_call_dstar_args(self):
def foo(x):
return x
expr = Expression("foo(**bar)")
self.assertEqual(42, expr.evaluate({'foo': foo, 'bar': {"x": 42}}))
def test_slice_copy(self):
expr = Expression("numbers[:]")
self.assertEqual([0, 1, 2, 3, 4], expr.evaluate({'numbers': range(5)}))
def test_slice_copy(self):
expr = Expression("numbers[:]")
self.assertEqual([0, 1, 2, 3, 4], expr.evaluate({'numbers': range(5)}))
def test_slice_negative_start(self):
expr = Expression("numbers[-1:]")
self.assertEqual([4], expr.evaluate({'numbers': range(5)}))
def test_builtins(self):
expr = Expression('Markup')
self.assertEqual(expr.evaluate({}), Markup)
def test_conditional_expression(self):
expr = Expression("'T' if foo else 'F'")
self.assertEqual('T', expr.evaluate({'foo': True}))
self.assertEqual('F', expr.evaluate({'foo': False}))
def test_lambda_tuple_arg(self):
data = {'items': [(1, 2), (2, 1)]}
expr = Expression("filter(lambda (x, y): x > y, items)")
self.assertEqual([(2, 1)], expr.evaluate(data))
def test_slice(self):
expr = Expression("numbers[0:2]")
self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
def test_lambda_tuple_arg(self):
data = {'items': [(1, 2), (2, 1)]}
expr = Expression("filter(lambda (x, y): x > y, items)")
self.assertEqual([(2, 1)], expr.evaluate(data))
