| # Copyright (c) 2006-2007, 2009-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr> |
| # Copyright (c) 2013-2016 Claudiu Popa <pcmanticore@gmail.com> |
| # Copyright (c) 2014 Google, Inc. |
| # Copyright (c) 2015 Florian Bruhin <me@the-compiler.org> |
| # Copyright (c) 2015-2016 Cara Vinson <ceridwenv@gmail.com> |
| |
| # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html |
| # For details: https://github.com/PyCQA/astroid/blob/master/COPYING.LESSER |
| |
| """tests for specific behaviour of astroid nodes |
| """ |
| import os |
| import sys |
| import textwrap |
| import unittest |
| import warnings |
| |
| import six |
| |
| import astroid |
| from astroid import builder |
| from astroid import context as contextmod |
| from astroid import exceptions |
| from astroid.tree import node_classes |
| from astroid import nodes |
| from astroid import parse |
| from astroid import raw_building |
| from astroid.interpreter import runtimeabc |
| from astroid.interpreter import objects |
| from astroid.interpreter import util as inferenceutil |
| from astroid import util |
| from astroid import test_utils |
| from astroid import transforms |
| from astroid.tests import resources |
| from astroid.tree import treeabc |
| |
| |
| abuilder = builder.AstroidBuilder() |
| BUILTINS = six.moves.builtins.__name__ |
| |
| |
| class AsStringTest(resources.SysPathSetup, unittest.TestCase): |
| |
| def test_tuple_as_string(self): |
| def build(string): |
| return abuilder.string_build(string).body[0].value |
| |
| self.assertEqual(build('1,').as_string(), '(1, )') |
| self.assertEqual(build('1, 2, 3').as_string(), '(1, 2, 3)') |
| self.assertEqual(build('(1, )').as_string(), '(1, )') |
| self.assertEqual(build('1, 2, 3').as_string(), '(1, 2, 3)') |
| |
| @test_utils.require_version(minver='3.0') |
| def test_func_signature_issue_185(self): |
| code = textwrap.dedent(''' |
| def test(a, b, c=42, *, x=42, **kwargs): |
| print(a, b, c, args) |
| ''') |
| node = parse(code) |
| self.assertEqual(node.as_string().strip(), code.strip()) |
| |
| def test_as_string_for_list_containing_uninferable(self): |
| node = astroid.extract_node(''' |
| def foo(): |
| bar = [arg] * 1 |
| ''') |
| binop = node.body[0].value |
| inferred = next(binop.infer()) |
| self.assertEqual(inferred.as_string(), '[Uninferable]') |
| self.assertEqual(binop.as_string(), '([arg]) * (1)') |
| |
| def test_frozenset_as_string(self): |
| nodes = astroid.extract_node(''' |
| frozenset((1, 2, 3)) #@ |
| frozenset({1, 2, 3}) #@ |
| frozenset([1, 2, 3,]) #@ |
| |
| frozenset(None) #@ |
| frozenset(1) #@ |
| ''') |
| nodes = [next(node.infer()) for node in nodes] |
| |
| self.assertEqual(nodes[0].as_string(), 'frozenset((1, 2, 3))') |
| self.assertEqual(nodes[1].as_string(), 'frozenset({1, 2, 3})') |
| self.assertEqual(nodes[2].as_string(), 'frozenset([1, 2, 3])') |
| |
| self.assertNotEqual(nodes[3].as_string(), 'frozenset(None)') |
| self.assertNotEqual(nodes[4].as_string(), 'frozenset(1)') |
| |
| def test_varargs_kwargs_as_string(self): |
| ast = abuilder.string_build('raise_string(*args, **kwargs)').body[0] |
| self.assertEqual(ast.as_string(), 'raise_string(*args, **kwargs)') |
| |
| def test_module_as_string(self): |
| """check as_string on a whole module prepared to be returned identically |
| """ |
| module = resources.build_file('data/module.py', 'data.module') |
| with open(resources.find('data/module.py'), 'r') as fobj: |
| self.assertMultiLineEqual(module.as_string(), fobj.read()) |
| |
| maxDiff = None |
| def test_module2_as_string(self): |
| """check as_string on a whole module prepared to be returned identically |
| """ |
| module2 = resources.build_file('data/module2.py', 'data.module2') |
| with open(resources.find('data/module2.py'), 'r') as fobj: |
| self.assertMultiLineEqual(module2.as_string(), fobj.read()) |
| |
| def test_as_string(self): |
| """check as_string for python syntax >= 2.7""" |
| code = '''one_two = {1, 2} |
| b = {v: k for (k, v) in enumerate('string')} |
| cdd = {k for k in b}\n\n''' |
| ast = abuilder.string_build(code) |
| self.assertMultiLineEqual(ast.as_string(), code) |
| |
| @test_utils.require_version('3.0') |
| def test_3k_as_string(self): |
| """check as_string for python 3k syntax""" |
| code = '''print() |
| |
| def function(var): |
| nonlocal counter |
| try: |
| hello |
| except NameError as nexc: |
| (*hell, o) = b'hello' |
| raise AttributeError from nexc |
| \n''' |
| ast = abuilder.string_build(code) |
| self.assertEqual(ast.as_string(), code) |
| |
| @test_utils.require_version('3.0') |
| @unittest.expectedFailure |
| def test_3k_annotations_and_metaclass(self): |
| code_annotations = textwrap.dedent(''' |
| def function(var:int): |
| nonlocal counter |
| |
| class Language(metaclass=Natural): |
| """natural language""" |
| ''') |
| |
| ast = abuilder.string_build(code_annotations) |
| self.assertEqual(ast.as_string(), code_annotations) |
| |
| def test_ellipsis(self): |
| ast = abuilder.string_build('a[...]').body[0] |
| self.assertEqual(ast.as_string(), 'a[...]') |
| |
| def test_slices(self): |
| for code in ('a[0]', 'a[1:3]', 'a[:-1:step]', 'a[:,newaxis]', |
| 'a[newaxis,:]', 'del L[::2]', 'del A[1]', 'del Br[:]'): |
| ast = abuilder.string_build(code).body[0] |
| self.assertEqual(ast.as_string(), code) |
| |
| def test_slice_and_subscripts(self): |
| code = """a[:1] = bord[2:] |
| a[:1] = bord[2:] |
| del bree[3:d] |
| bord[2:] |
| del av[d::f], a[df:] |
| a[:1] = bord[2:] |
| del SRC[::1,newaxis,1:] |
| tous[vals] = 1010 |
| del thousand[key] |
| del a[::2], a[:-1:step] |
| del Fee.form[left:] |
| aout.vals = miles.of_stuff |
| del (ccok, (name.thing, foo.attrib.value)), Fee.form[left:] |
| if all[1] == bord[0:]: |
| pass\n\n""" |
| ast = abuilder.string_build(code) |
| self.assertEqual(ast.as_string(), code) |
| |
| |
| class _NodeTest(unittest.TestCase): |
| """test transformation of If Node""" |
| CODE = None |
| |
| @property |
| def astroid(self): |
| try: |
| return self.__class__.__dict__['CODE_Astroid'] |
| except KeyError: |
| astroid = builder.parse(self.CODE) |
| self.__class__.CODE_Astroid = astroid |
| return astroid |
| |
| |
| class IfNodeTest(_NodeTest): |
| """test transformation of If Node""" |
| CODE = """ |
| if 0: |
| print() |
| |
| if True: |
| print() |
| else: |
| pass |
| |
| if "": |
| print() |
| elif []: |
| raise |
| |
| if 1: |
| print() |
| elif True: |
| print() |
| elif func(): |
| pass |
| else: |
| raise |
| """ |
| |
| def test_if_elif_else_node(self): |
| """test transformation for If node""" |
| self.assertEqual(len(self.astroid.body), 4) |
| for stmt in self.astroid.body: |
| self.assertIsInstance(stmt, nodes.If) |
| self.assertFalse(self.astroid.body[0].orelse) # simple If |
| self.assertIsInstance(self.astroid.body[1].orelse[0], nodes.Pass) # If / else |
| self.assertIsInstance(self.astroid.body[2].orelse[0], nodes.If) # If / elif |
| self.assertIsInstance(self.astroid.body[3].orelse[0].orelse[0], nodes.If) |
| |
| def test_block_range(self): |
| # XXX ensure expected values |
| self.assertEqual(self.astroid.block_range(1), (0, 22)) |
| self.assertEqual(self.astroid.block_range(10), (0, 22)) # XXX (10, 22) ? |
| self.assertEqual(self.astroid.body[1].block_range(5), (5, 6)) |
| self.assertEqual(self.astroid.body[1].block_range(6), (6, 6)) |
| self.assertEqual(self.astroid.body[1].orelse[0].block_range(7), (7, 8)) |
| self.assertEqual(self.astroid.body[1].orelse[0].block_range(8), (8, 8)) |
| |
| |
| class TryExceptNodeTest(_NodeTest): |
| CODE = """ |
| try: |
| print ('pouet') |
| except IOError: |
| pass |
| except UnicodeError: |
| print() |
| else: |
| print() |
| """ |
| |
| def test_block_range(self): |
| # XXX ensure expected values |
| self.assertEqual(self.astroid.body[0].block_range(1), (1, 8)) |
| self.assertEqual(self.astroid.body[0].block_range(2), (2, 2)) |
| self.assertEqual(self.astroid.body[0].block_range(3), (3, 8)) |
| self.assertEqual(self.astroid.body[0].block_range(4), (4, 4)) |
| self.assertEqual(self.astroid.body[0].block_range(5), (5, 5)) |
| self.assertEqual(self.astroid.body[0].block_range(6), (6, 6)) |
| self.assertEqual(self.astroid.body[0].block_range(7), (7, 7)) |
| self.assertEqual(self.astroid.body[0].block_range(8), (8, 8)) |
| |
| |
| class TryFinallyNodeTest(_NodeTest): |
| CODE = """ |
| try: |
| print ('pouet') |
| finally: |
| print ('pouet') |
| """ |
| |
| def test_block_range(self): |
| # XXX ensure expected values |
| self.assertEqual(self.astroid.body[0].block_range(1), (1, 4)) |
| self.assertEqual(self.astroid.body[0].block_range(2), (2, 2)) |
| self.assertEqual(self.astroid.body[0].block_range(3), (3, 4)) |
| self.assertEqual(self.astroid.body[0].block_range(4), (4, 4)) |
| |
| |
| class TryExceptFinallyNodeTest(_NodeTest): |
| CODE = """ |
| try: |
| print('pouet') |
| except Exception: |
| print ('oops') |
| finally: |
| print ('pouet') |
| """ |
| |
| def test_block_range(self): |
| # XXX ensure expected values |
| self.assertEqual(self.astroid.body[0].block_range(1), (1, 6)) |
| self.assertEqual(self.astroid.body[0].block_range(2), (2, 2)) |
| self.assertEqual(self.astroid.body[0].block_range(3), (3, 4)) |
| self.assertEqual(self.astroid.body[0].block_range(4), (4, 4)) |
| self.assertEqual(self.astroid.body[0].block_range(5), (5, 5)) |
| self.assertEqual(self.astroid.body[0].block_range(6), (6, 6)) |
| |
| |
| @unittest.skipIf(six.PY3, "Python 2 specific test.") |
| class TryExcept2xNodeTest(_NodeTest): |
| CODE = """ |
| try: |
| hello |
| except AttributeError, (retval, desc): |
| pass |
| """ |
| |
| |
| def test_tuple_attribute(self): |
| handler = self.astroid.body[0].handlers[0] |
| self.assertIsInstance(handler.name, nodes.Tuple) |
| |
| |
| class ImportNodeTest(resources.SysPathSetup, unittest.TestCase): |
| def setUp(self): |
| super(ImportNodeTest, self).setUp() |
| self.module = resources.build_file('data/module.py', 'data.module') |
| self.module2 = resources.build_file('data/module2.py', 'data.module2') |
| |
| def test_do_import_module_works_for_all(self): |
| import_from, import_ = astroid.extract_node(''' |
| from collections import deque #@ |
| import collections #@ |
| ''') |
| inferred = inferenceutil.do_import_module(import_from, 'collections') |
| self.assertIsInstance(inferred, nodes.Module) |
| self.assertEqual(inferred.name, 'collections') |
| inferred = inferenceutil.do_import_module(import_, 'collections') |
| self.assertIsInstance(inferred, nodes.Module) |
| self.assertEqual(inferred.name, 'collections') |
| |
| def test_import_self_resolve(self): |
| myos = next(self.module2.igetattr('myos')) |
| self.assertTrue(isinstance(myos, nodes.Module), myos) |
| self.assertEqual(myos.name, 'os') |
| self.assertEqual(myos.qname(), 'os') |
| self.assertEqual(myos.pytype(), '%s.module' % BUILTINS) |
| |
| def test_from_self_resolve(self): |
| namenode = next(self.module.igetattr('NameNode')) |
| self.assertTrue(isinstance(namenode, nodes.ClassDef), namenode) |
| self.assertEqual(namenode.root().name, 'astroid.tree.node_classes') |
| self.assertEqual(namenode.qname(), 'astroid.tree.node_classes.Name') |
| self.assertEqual(namenode.pytype(), '%s.type' % BUILTINS) |
| abspath = next(self.module2.igetattr('abspath')) |
| self.assertTrue(isinstance(abspath, nodes.FunctionDef), abspath) |
| self.assertEqual(abspath.root().name, 'os.path') |
| self.assertEqual(abspath.qname(), 'os.path.abspath') |
| self.assertEqual(abspath.pytype(), '%s.function' % BUILTINS) |
| |
| def test_real_name(self): |
| from_ = self.module['NameNode'] |
| self.assertEqual(inferenceutil.real_name(from_, 'NameNode'), 'Name') |
| imp_ = self.module['os'] |
| self.assertEqual(inferenceutil.real_name(imp_, 'os'), 'os') |
| self.assertRaises(exceptions.AttributeInferenceError, |
| inferenceutil.real_name, imp_, 'os.path') |
| imp_ = self.module['NameNode'] |
| self.assertEqual(inferenceutil.real_name(imp_, 'NameNode'), 'Name') |
| self.assertRaises(exceptions.AttributeInferenceError, |
| inferenceutil.real_name, imp_, 'Name') |
| imp_ = self.module2['YO'] |
| self.assertEqual(inferenceutil.real_name(imp_, 'YO'), 'YO') |
| self.assertRaises(exceptions.AttributeInferenceError, |
| inferenceutil.real_name, imp_, 'data') |
| |
| def test_as_string(self): |
| ast = self.module['modutils'] |
| self.assertEqual(ast.as_string(), "from astroid import modutils") |
| ast = self.module['NameNode'] |
| self.assertEqual(ast.as_string(), "from astroid.tree.node_classes import Name as NameNode") |
| ast = self.module['os'] |
| self.assertEqual(ast.as_string(), "import os.path") |
| code = """from . import here |
| from .. import door |
| from .store import bread |
| from ..cave import wine\n\n""" |
| ast = abuilder.string_build(code) |
| self.assertMultiLineEqual(ast.as_string(), code) |
| |
| def test_bad_import_inference(self): |
| # Explication of bug |
| '''When we import PickleError from nonexistent, a call to the infer |
| method of this From node will be made by unpack_infer. |
| inference.infer_from will try to import this module, which will fail and |
| raise a InferenceException (by mixins.do_import_module). The infer_name |
| will catch this exception and yield and Uninferable instead. |
| ''' |
| |
| code = ''' |
| try: |
| from pickle import PickleError |
| except ImportError: |
| from nonexistent import PickleError |
| |
| try: |
| pass |
| except PickleError: |
| pass |
| ''' |
| astroid = builder.parse(code) |
| handler_type = astroid.body[1].handlers[0].type |
| |
| excs = list(inferenceutil.unpack_infer(handler_type)) |
| # The number of returned object can differ on Python 2 |
| # and Python 3. In one version, an additional item will |
| # be returned, from the _pickle module, which is not |
| # present in the other version. |
| self.assertIsInstance(excs[0], nodes.ClassDef) |
| self.assertEqual(excs[0].name, 'PickleError') |
| self.assertIs(excs[-1], util.Uninferable) |
| |
| def test_absolute_import(self): |
| astroid = resources.build_file('data/absimport.py') |
| ctx = contextmod.InferenceContext() |
| # will fail if absolute import failed |
| ctx.lookupname = 'message' |
| next(astroid['message'].infer(ctx)) |
| ctx.lookupname = 'email' |
| m = next(astroid['email'].infer(ctx)) |
| self.assertFalse(m.source_file.startswith(os.path.join('data', 'email.py'))) |
| |
| def test_more_absolute_import(self): |
| astroid = resources.build_file('data/module1abs/__init__.py', 'data.module1abs') |
| self.assertIn('sys', astroid.locals) |
| |
| |
| class CmpNodeTest(unittest.TestCase): |
| def test_as_string(self): |
| ast = abuilder.string_build("a == 2").body[0] |
| self.assertEqual(ast.as_string(), "a == 2") |
| |
| |
| class ConstNodeTest(unittest.TestCase): |
| |
| def _test(self, value): |
| node = raw_building.ast_from_object(value) |
| self.assertIsInstance(node._proxied, (nodes.ClassDef, nodes.AssignName)) |
| self.assertEqual(node._proxied.name, value.__class__.__name__) |
| self.assertIs(node.value, value) |
| self.assertTrue(node._proxied.parent) |
| self.assertEqual(node._proxied.root().name, value.__class__.__module__) |
| |
| def test_none(self): |
| self._test(None) |
| |
| def test_bool(self): |
| self._test(True) |
| |
| def test_int(self): |
| self._test(1) |
| |
| def test_float(self): |
| self._test(1.0) |
| |
| def test_complex(self): |
| self._test(1.0j) |
| |
| def test_str(self): |
| self._test('a') |
| |
| def test_unicode(self): |
| self._test(u'a') |
| |
| |
| class NameNodeTest(unittest.TestCase): |
| def test_assign_to_True(self): |
| """test that True and False assignements don't crash""" |
| code = """ |
| True = False |
| def hello(False): |
| pass |
| del True |
| """ |
| if sys.version_info >= (3, 0): |
| with self.assertRaises(exceptions.AstroidBuildingError): |
| builder.parse(code) |
| else: |
| ast = builder.parse(code) |
| assign_true = ast['True'] |
| self.assertIsInstance(assign_true, nodes.AssignName) |
| self.assertEqual(assign_true.name, "True") |
| del_true = ast.body[2].targets[0] |
| self.assertIsInstance(del_true, nodes.DelName) |
| self.assertEqual(del_true.name, "True") |
| |
| |
| class ArgumentsNodeTC(unittest.TestCase): |
| |
| @unittest.skipIf(sys.version_info[:2] == (3, 3), |
| "Line numbering is broken on Python 3.3.") |
| def test_linenumbering(self): |
| ast = builder.parse(''' |
| def func(a, |
| b): pass |
| x = lambda x: None |
| ''') |
| self.assertEqual(ast['func'].args.fromlineno, 2) |
| self.assertFalse(ast['func'].args.is_statement) |
| xlambda = next(ast['x'].infer()) |
| self.assertEqual(xlambda.args.fromlineno, 4) |
| self.assertEqual(xlambda.args.tolineno, 4) |
| self.assertFalse(xlambda.args.is_statement) |
| if sys.version_info < (3, 0): |
| self.assertEqual(ast['func'].args.tolineno, 3) |
| else: |
| self.skipTest('FIXME http://bugs.python.org/issue10445 ' |
| '(no line number on function args)') |
| |
| @test_utils.require_version(minver='3.0') |
| def test_kwoargs(self): |
| ast = builder.parse(''' |
| def func(*, x): |
| pass |
| ''') |
| args = ast['func'].args |
| self.assertTrue(args.is_argument('x')) |
| |
| |
| class UnboundMethodNodeTest(unittest.TestCase): |
| |
| def test_no_super_getattr(self): |
| # This is a test for issue |
| # https://bitbucket.org/logilab/astroid/issue/91, which tests |
| # that UnboundMethod doesn't call super when doing .getattr. |
| |
| ast = builder.parse(''' |
| class A(object): |
| def test(self): |
| pass |
| meth = A.test |
| ''') |
| node = next(ast['meth'].infer()) |
| with self.assertRaises(exceptions.AttributeInferenceError): |
| node.getattr('__missssing__') |
| name = node.getattr('__name__')[0] |
| self.assertIsInstance(name, nodes.Const) |
| self.assertEqual(name.value, 'test') |
| |
| |
| class BoundMethodNodeTest(unittest.TestCase): |
| |
| def test_is_property(self): |
| ast = builder.parse(''' |
| import abc |
| |
| def cached_property(): |
| # Not a real decorator, but we don't care |
| pass |
| def reify(): |
| # Same as cached_property |
| pass |
| def lazy_property(): |
| pass |
| def lazyproperty(): |
| pass |
| def lazy(): pass |
| class A(object): |
| @property |
| def builtin_property(self): |
| return 42 |
| @abc.abstractproperty |
| def abc_property(self): |
| return 42 |
| @cached_property |
| def cached_property(self): return 42 |
| @reify |
| def reified(self): return 42 |
| @lazy_property |
| def lazy_prop(self): return 42 |
| @lazyproperty |
| def lazyprop(self): return 42 |
| def not_prop(self): pass |
| @lazy |
| def decorated_with_lazy(self): return 42 |
| |
| cls = A() |
| builtin_property = cls.builtin_property |
| abc_property = cls.abc_property |
| cached_p = cls.cached_property |
| reified = cls.reified |
| not_prop = cls.not_prop |
| lazy_prop = cls.lazy_prop |
| lazyprop = cls.lazyprop |
| decorated_with_lazy = cls.decorated_with_lazy |
| ''') |
| for prop in ('builtin_property', 'abc_property', 'cached_p', 'reified', |
| 'lazy_prop', 'lazyprop', 'decorated_with_lazy'): |
| inferred = next(ast[prop].infer()) |
| self.assertIsInstance(inferred, nodes.Const, prop) |
| self.assertEqual(inferred.value, 42, prop) |
| |
| inferred = next(ast['not_prop'].infer()) |
| self.assertIsInstance(inferred, objects.BoundMethod) |
| |
| |
| @test_utils.require_version('3.5') |
| class Python35AsyncTest(unittest.TestCase): |
| |
| def test_async_await_keywords(self): |
| async_def, async_for, async_with, await_node = astroid.extract_node(''' |
| async def func(): #@ |
| async for i in range(10): #@ |
| f = __(await i) |
| async with test(): #@ |
| pass |
| ''') |
| self.assertIsInstance(async_def, nodes.AsyncFunctionDef) |
| self.assertIsInstance(async_for, nodes.AsyncFor) |
| self.assertIsInstance(async_with, nodes.AsyncWith) |
| self.assertIsInstance(await_node, nodes.Await) |
| self.assertIsInstance(await_node.value, nodes.Name) |
| |
| def _test_await_async_as_string(self, code): |
| ast_node = parse(code) |
| self.assertEqual(ast_node.as_string().strip(), code.strip()) |
| |
| def test_await_as_string(self): |
| code = textwrap.dedent(''' |
| async def function(): |
| await 42 |
| ''') |
| self._test_await_async_as_string(code) |
| |
| def test_asyncwith_as_string(self): |
| code = textwrap.dedent(''' |
| async def function(): |
| async with (42): |
| pass |
| ''') |
| self._test_await_async_as_string(code) |
| |
| def test_asyncfor_as_string(self): |
| code = textwrap.dedent(''' |
| async def function(): |
| async for i in range(10): |
| await 42 |
| ''') |
| self._test_await_async_as_string(code) |
| |
| |
| class BaseTypesTest(unittest.TestCase): |
| |
| def test_concrete_issubclass(self): |
| for node in nodes.ALL_NODE_CLASSES: |
| name = node.__name__ |
| base_type = getattr(treeabc, name) |
| self.assertTrue(issubclass(node, base_type), (node, base_type)) |
| |
| self.assertTrue(issubclass(objects.Instance, runtimeabc.Instance)) |
| self.assertTrue(issubclass(objects.Generator, runtimeabc.Generator)) |
| self.assertTrue(issubclass(objects.BoundMethod, runtimeabc.BoundMethod)) |
| self.assertTrue(issubclass(objects.UnboundMethod, runtimeabc.UnboundMethod)) |
| |
| |
| class ScopeTest(unittest.TestCase): |
| |
| def test_decorators(self): |
| ast_node = astroid.extract_node(''' |
| @test |
| def foo(): pass |
| ''') |
| decorators = ast_node.decorators |
| self.assertIsInstance(decorators.scope(), nodes.Module) |
| self.assertEqual(decorators.scope(), decorators.root()) |
| |
| def test_scoped_nodes(self): |
| module = parse(''' |
| def function(): |
| pass |
| genexp = (i for i in range(10)) |
| dictcomp = {i:i for i in range(10)} |
| setcomp = {i for i in range(10)} |
| listcomp = [i for i in range(10)] |
| lambd = lambda x: x |
| class classdef: pass |
| ''') |
| self.assertIsInstance(module.scope(), nodes.Module) |
| self.assertIsInstance(module['genexp'].parent.value.scope(), nodes.GeneratorExp) |
| self.assertIsInstance(module['dictcomp'].parent.value.scope(), nodes.DictComp) |
| self.assertIsInstance(module['setcomp'].parent.value.scope(), nodes.SetComp) |
| self.assertIsInstance(module['lambd'].parent.value.scope(), nodes.Lambda) |
| self.assertIsInstance(next(module['function'].infer()).scope(), nodes.FunctionDef) |
| self.assertIsInstance(next(module['classdef'].infer()).scope(), nodes.ClassDef) |
| |
| if six.PY3: |
| self.assertIsInstance(module['listcomp'].parent.value.scope(), nodes.ListComp) |
| else: |
| self.assertIsInstance(module['listcomp'].parent.value.scope(), nodes.Module) |
| |
| def test_scope_of_default_argument_value(self): |
| node = astroid.extract_node(''' |
| def test(a=__(b)): |
| pass |
| ''') |
| scope = node.scope() |
| self.assertIsInstance(scope, nodes.Module) |
| |
| @test_utils.require_version(minver='3.0') |
| def test_scope_of_default_keyword_argument_value(self): |
| node = astroid.extract_node(''' |
| def test(*, b=__(c)): |
| pass |
| ''') |
| scope = node.scope() |
| self.assertIsInstance(scope, nodes.Module) |
| |
| @test_utils.require_version(minver='3.0') |
| def test_scope_of_annotations(self): |
| ast_nodes = astroid.extract_node(''' |
| def test(a: __(b), *args:__(f), c:__(d)=4, **kwargs: _(l))->__(x): |
| pass |
| ''') |
| for node in ast_nodes: |
| scope = node.scope() |
| self.assertIsInstance(scope, nodes.Module) |
| |
| def test_scope_of_list_comprehension_target_composite_nodes(self): |
| ast_node = astroid.extract_node(''' |
| [i for data in __([DATA1, DATA2]) for i in data] |
| ''') |
| node = ast_node.elts[0] |
| scope = node.scope() |
| self.assertIsInstance(scope, nodes.Module) |
| |
| def test_scope_of_nested_list_comprehensions(self): |
| ast_node = astroid.extract_node(''' |
| [1 for data in DATA for x in __(data)] |
| ''') |
| scope = ast_node.scope() |
| if six.PY2: |
| self.assertIsInstance(scope, nodes.Module) |
| else: |
| self.assertIsInstance(scope, nodes.ListComp) |
| |
| def test_scope_of_list_comprehension_targets(self): |
| ast_node = astroid.extract_node(''' |
| [1 for data in DATA] |
| ''') |
| # target is `data` from the list comprehension |
| target = ast_node.generators[0].target |
| scope = target.scope() |
| if six.PY2: |
| self.assertIsInstance(scope, nodes.Module) |
| else: |
| self.assertIsInstance(scope, nodes.ListComp) |
| |
| def test_scope_of_list_comprehension_value(self): |
| ast_node = astroid.extract_node(''' |
| [__(i) for i in DATA] |
| ''') |
| scope = ast_node.scope() |
| if six.PY3: |
| self.assertIsInstance(scope, nodes.ListComp) |
| else: |
| self.assertIsInstance(scope, nodes.Module) |
| |
| def test_scope_of_dict_comprehension(self): |
| ast_nodes = astroid.extract_node(''' |
| {i: __(j) for (i, j) in DATA} |
| {i:j for (i, j) in __(DATA)} |
| ''') |
| elt_scope = ast_nodes[0].scope() |
| self.assertIsInstance(elt_scope, nodes.DictComp) |
| iter_scope = ast_nodes[1].scope() |
| self.assertIsInstance(iter_scope, nodes.Module) |
| |
| ast_node = astroid.extract_node(''' |
| {i:1 for i in DATA}''') |
| target = ast_node.generators[0].target |
| target_scope = target.scope() |
| self.assertIsInstance(target_scope, nodes.DictComp) |
| |
| def test_scope_elt_of_generator_exp(self): |
| ast_node = astroid.extract_node(''' |
| list(__(i) for i in range(10)) |
| ''') |
| scope = ast_node.scope() |
| self.assertIsInstance(scope, nodes.GeneratorExp) |
| |
| |
| class ContextTest(unittest.TestCase): |
| |
| def test_subscript_load(self): |
| node = astroid.extract_node('f[1]') |
| self.assertIs(node.ctx, astroid.Load) |
| |
| def test_subscript_del(self): |
| node = astroid.extract_node('del f[1]') |
| self.assertIs(node.targets[0].ctx, astroid.Del) |
| |
| def test_subscript_store(self): |
| node = astroid.extract_node('f[1] = 2') |
| subscript = node.targets[0] |
| self.assertIs(subscript.ctx, astroid.Store) |
| |
| def test_list_load(self): |
| node = astroid.extract_node('[]') |
| self.assertIs(node.ctx, astroid.Load) |
| |
| def test_list_del(self): |
| node = astroid.extract_node('del []') |
| self.assertIs(node.targets[0].ctx, astroid.Del) |
| |
| def test_list_store(self): |
| with self.assertRaises(exceptions.AstroidSyntaxError): |
| astroid.extract_node('[0] = 2') |
| |
| def test_tuple_load(self): |
| node = astroid.extract_node('(1, )') |
| self.assertIs(node.ctx, astroid.Load) |
| |
| def test_tuple_store(self): |
| with self.assertRaises(exceptions.AstroidSyntaxError): |
| astroid.extract_node('(1, ) = 3') |
| |
| @test_utils.require_version(minver='3.5') |
| def test_starred_load(self): |
| node = astroid.extract_node('a = *b') |
| starred = node.value |
| self.assertIs(starred.ctx, astroid.Load) |
| |
| @test_utils.require_version(minver='3.0') |
| def test_starred_store(self): |
| node = astroid.extract_node('a, *b = 1, 2') |
| starred = node.targets[0].elts[1] |
| self.assertIs(starred.ctx, astroid.Store) |
| |
| |
| class FunctionTest(unittest.TestCase): |
| |
| def test_function_not_on_top_of_lambda(self): |
| lambda_, function_ = astroid.extract_node(''' |
| lambda x: x #@ |
| def func(): pass #@ |
| ''') |
| self.assertNotIsInstance(lambda_, astroid.FunctionDef) |
| self.assertNotIsInstance(function_, astroid.Lambda) |
| |
| |
| class DictTest(unittest.TestCase): |
| |
| def test_keys_values_items(self): |
| node = astroid.extract_node(''' |
| {1: 2, 2:3} |
| ''') |
| self.assertEqual([key.value for key in node.keys], [1, 2]) |
| self.assertEqual([value.value for value in node.values], [2, 3]) |
| self.assertEqual([(key.value, value.value) for (key, value) in node.items], |
| [(1, 2), (2, 3)]) |
| |
| |
| class ParameterTest(unittest.TestCase): |
| |
| def _variadics_test_helper(self, vararg_lineno, vararg_col_offset, |
| kwarg_lineno, kwarg_col_offset): |
| node = astroid.extract_node(''' |
| def test(*args, **kwargs): pass |
| ''') |
| args = node.args |
| self.assertIsInstance(args.vararg, astroid.Parameter) |
| self.assertEqual(args.vararg.lineno, vararg_lineno) |
| self.assertEqual(args.vararg.col_offset, vararg_col_offset) |
| self.assertIsInstance(args.kwarg, astroid.Parameter) |
| self.assertEqual(args.kwarg.lineno, kwarg_lineno) |
| self.assertEqual(args.kwarg.col_offset, kwarg_col_offset) |
| |
| @unittest.skipUnless(sys.version_info[:2] < (3, 5), |
| "variadics support lineno & col_offset in 3.5+") |
| def test_no_lineno_for_variadics(self): |
| self._variadics_test_helper(vararg_lineno=None, vararg_col_offset=None, |
| kwarg_lineno=None, kwarg_col_offset=None) |
| |
| @unittest.skipUnless(sys.version_info[:2] >= (3, 5), |
| "variadics support lineno & col_offset in 3.5+") |
| def test_no_lineno_for_variadics(self): |
| self._variadics_test_helper(vararg_lineno=2, vararg_col_offset=10, |
| kwarg_lineno=2, kwarg_col_offset=18) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
