| import unittest |
| |
| from mako import ast, exceptions, pyparser, util |
| from test import eq_ |
| |
| exception_kwargs = {'source':'', 'lineno':0, 'pos':0, 'filename':''} |
| |
| class AstParseTest(unittest.TestCase): |
| |
| def test_locate_identifiers(self): |
| """test the location of identifiers in a python code string""" |
| code = """ |
| a = 10 |
| b = 5 |
| c = x * 5 + a + b + q |
| (g,h,i) = (1,2,3) |
| [u,k,j] = [4,5,6] |
| foo.hoho.lala.bar = 7 + gah.blah + u + blah |
| for lar in (1,2,3): |
| gh = 5 |
| x = 12 |
| ("hello world, ", a, b) |
| ("Another expr", c) |
| """ |
| parsed = ast.PythonCode(code, **exception_kwargs) |
| assert parsed.declared_identifiers == set(['a','b','c', 'g', 'h', 'i', 'u', 'k', 'j', 'gh', 'lar', 'x']) |
| assert parsed.undeclared_identifiers == set(['x', 'q', 'foo', 'gah', 'blah']) |
| |
| parsed = ast.PythonCode("x + 5 * (y-z)", **exception_kwargs) |
| assert parsed.undeclared_identifiers == set(['x', 'y', 'z']) |
| assert parsed.declared_identifiers == set() |
| |
| def test_locate_identifiers_2(self): |
| code = """ |
| import foobar |
| from lala import hoho, yaya |
| import bleep as foo |
| result = [] |
| data = get_data() |
| for x in data: |
| result.append(x+7) |
| """ |
| parsed = ast.PythonCode(code, **exception_kwargs) |
| assert parsed.undeclared_identifiers == set(['get_data']) |
| assert parsed.declared_identifiers == set(['result', 'data', 'x', 'hoho', 'foobar', 'foo', 'yaya']) |
| |
| def test_locate_identifiers_3(self): |
| """test that combination assignment/expressions of the same identifier log the ident as 'undeclared'""" |
| code = """ |
| x = x + 5 |
| for y in range(1, y): |
| ("hi",) |
| [z for z in range(1, z)] |
| (q for q in range (1, q)) |
| """ |
| parsed = ast.PythonCode(code, **exception_kwargs) |
| assert parsed.undeclared_identifiers == set(['x', 'y', 'z', 'q', 'range']) |
| |
| def test_locate_identifiers_4(self): |
| if util.py3k: |
| code = """ |
| x = 5 |
| (y, ) |
| def mydef(mydefarg): |
| print("mda is", mydefarg) |
| """ |
| else: |
| code = """ |
| x = 5 |
| (y, ) |
| def mydef(mydefarg): |
| print "mda is", mydefarg |
| """ |
| parsed = ast.PythonCode(code, **exception_kwargs) |
| assert parsed.undeclared_identifiers == set(['y']) |
| assert parsed.declared_identifiers == set(['mydef', 'x']) |
| |
| def test_locate_identifiers_5(self): |
| if util.py3k: |
| code = """ |
| try: |
| print(x) |
| except: |
| print(y) |
| """ |
| else: |
| |
| code = """ |
| try: |
| print x |
| except: |
| print y |
| """ |
| parsed = ast.PythonCode(code, **exception_kwargs) |
| assert parsed.undeclared_identifiers == set(['x', 'y']) |
| |
| def test_locate_identifiers_6(self): |
| code = """ |
| def foo(): |
| return bar() |
| """ |
| parsed = ast.PythonCode(code, **exception_kwargs) |
| assert parsed.undeclared_identifiers == set(['bar']) |
| |
| if util.py3k: |
| code = """ |
| def lala(x, y): |
| return x, y, z |
| print(x) |
| """ |
| else: |
| code = """ |
| def lala(x, y): |
| return x, y, z |
| print x |
| """ |
| parsed = ast.PythonCode(code, **exception_kwargs) |
| assert parsed.undeclared_identifiers == set(['z', 'x']) |
| assert parsed.declared_identifiers == set(['lala']) |
| |
| if util.py3k: |
| code = """ |
| def lala(x, y): |
| def hoho(): |
| def bar(): |
| z = 7 |
| print(z) |
| """ |
| else: |
| code = """ |
| def lala(x, y): |
| def hoho(): |
| def bar(): |
| z = 7 |
| print z |
| """ |
| parsed = ast.PythonCode(code, **exception_kwargs) |
| assert parsed.undeclared_identifiers == set(['z']) |
| assert parsed.declared_identifiers == set(['lala']) |
| |
| def test_locate_identifiers_7(self): |
| code = """ |
| import foo.bar |
| """ |
| parsed = ast.PythonCode(code, **exception_kwargs) |
| assert parsed.declared_identifiers == set(['foo']) |
| assert parsed.undeclared_identifiers == set() |
| |
| def test_locate_identifiers_8(self): |
| code = """ |
| class Hi(object): |
| foo = 7 |
| def hoho(self): |
| x = 5 |
| """ |
| parsed = ast.PythonCode(code, **exception_kwargs) |
| assert parsed.declared_identifiers == set(['Hi']) |
| assert parsed.undeclared_identifiers == set() |
| |
| def test_no_global_imports(self): |
| code = """ |
| from foo import * |
| import x as bar |
| """ |
| self.assertRaises(exceptions.CompileException, ast.PythonCode, code, **exception_kwargs) |
| |
| def test_python_fragment(self): |
| parsed = ast.PythonFragment("for x in foo:", **exception_kwargs) |
| assert parsed.declared_identifiers == set(['x']) |
| assert parsed.undeclared_identifiers == set(['foo']) |
| |
| parsed = ast.PythonFragment("try:", **exception_kwargs) |
| |
| if util.py3k: |
| parsed = ast.PythonFragment("except MyException as e:", **exception_kwargs) |
| else: |
| parsed = ast.PythonFragment("except MyException, e:", **exception_kwargs) |
| eq_(parsed.declared_identifiers, set(['e'])) |
| eq_(parsed.undeclared_identifiers, set(['MyException'])) |
| |
| def test_argument_list(self): |
| parsed = ast.ArgumentList("3, 5, 'hi', x+5, context.get('lala')", **exception_kwargs) |
| assert parsed.undeclared_identifiers == set(['x', 'context']) |
| assert [x for x in parsed.args] == ["3", "5", "'hi'", "(x + 5)", "context.get('lala')"] |
| |
| parsed = ast.ArgumentList("h", **exception_kwargs) |
| assert parsed.args == ["h"] |
| |
| def test_function_decl(self): |
| """test getting the arguments from a function""" |
| code = "def foo(a, b, c=None, d='hi', e=x, f=y+7):pass" |
| parsed = ast.FunctionDecl(code, **exception_kwargs) |
| assert parsed.funcname=='foo' |
| assert parsed.argnames==['a', 'b', 'c', 'd', 'e', 'f'] |
| |
| def test_function_decl_2(self): |
| """test getting the arguments from a function""" |
| code = "def foo(a, b, c=None, *args, **kwargs):pass" |
| parsed = ast.FunctionDecl(code, **exception_kwargs) |
| assert parsed.funcname=='foo' |
| assert parsed.argnames==['a', 'b', 'c', 'args', 'kwargs'] |
| |
| def test_expr_generate(self): |
| """test the round trip of expressions to AST back to python source""" |
| x = 1 |
| y = 2 |
| class F(object): |
| def bar(self, a,b): |
| return a + b |
| def lala(arg): |
| return "blah" + arg |
| local_dict = dict(x=x, y=y, foo=F(), lala=lala) |
| |
| code = "str((x+7*y) / foo.bar(5,6)) + lala('ho')" |
| astnode = pyparser.parse(code) |
| newcode = pyparser.ExpressionGenerator(astnode).value() |
| assert (eval(code, local_dict) == eval(newcode, local_dict)) |
| |
| a = ["one", "two", "three"] |
| hoho = {'somevalue':"asdf"} |
| g = [1,2,3,4,5] |
| local_dict = dict(a=a,hoho=hoho,g=g) |
| code = "a[2] + hoho['somevalue'] + repr(g[3:5]) + repr(g[3:]) + repr(g[:5])" |
| astnode = pyparser.parse(code) |
| newcode = pyparser.ExpressionGenerator(astnode).value() |
| assert(eval(code, local_dict) == eval(newcode, local_dict)) |
| |
| local_dict={'f':lambda :9, 'x':7} |
| code = "x+f()" |
| astnode = pyparser.parse(code) |
| newcode = pyparser.ExpressionGenerator(astnode).value() |
| assert(eval(code, local_dict)) == eval(newcode, local_dict) |
| |
| for code in ["repr({'x':7,'y':18})", "repr([])", "repr({})", "repr([{3:[]}])", "repr({'x':37*2 + len([6,7,8])})", "repr([1, 2, {}, {'x':'7'}])", "repr({'x':-1})", "repr(((1,2,3), (4,5,6)))", "repr(1 and 2 and 3 and 4)", "repr(True and False or 55)", "repr(1 & 2 | 3)", "repr(3//5)", "repr(3^5)", "repr([q.endswith('e') for q in ['one', 'two', 'three']])", "repr([x for x in (5,6,7) if x == 6])", "repr(not False)"]: |
| local_dict={} |
| astnode = pyparser.parse(code) |
| newcode = pyparser.ExpressionGenerator(astnode).value() |
| assert(eval(code, local_dict)) == eval(newcode, local_dict), "%s != %s" % (code, newcode) |
| |
| |
| |