diff options
Diffstat (limited to 'pyflakes/test/test_checker.py')
| -rw-r--r-- | pyflakes/test/test_checker.py | 184 |
1 files changed, 0 insertions, 184 deletions
diff --git a/pyflakes/test/test_checker.py b/pyflakes/test/test_checker.py deleted file mode 100644 index 66e3501..0000000 --- a/pyflakes/test/test_checker.py +++ /dev/null @@ -1,184 +0,0 @@ -import ast - -from pyflakes import checker -from pyflakes.test.harness import TestCase - - -class TypeableVisitorTests(TestCase): - """ - Tests of L{_TypeableVisitor} - """ - - @staticmethod - def _run_visitor(s): - """ - Run L{_TypeableVisitor} on the parsed source and return the visitor. - """ - tree = ast.parse(s) - visitor = checker._TypeableVisitor() - visitor.visit(tree) - return visitor - - def test_node_types(self): - """ - Test that the typeable node types are collected - """ - visitor = self._run_visitor( - """\ -x = 1 # assignment -for x in range(1): pass # for loop -def f(): pass # function definition -with a as b: pass # with statement -""" - ) - self.assertEqual(visitor.typeable_lines, [1, 2, 3, 4]) - self.assertIsInstance(visitor.typeable_nodes[1], ast.Assign) - self.assertIsInstance(visitor.typeable_nodes[2], ast.For) - self.assertIsInstance(visitor.typeable_nodes[3], ast.FunctionDef) - self.assertIsInstance(visitor.typeable_nodes[4], ast.With) - - def test_visitor_recurses(self): - """ - Test the common pitfall of missing `generic_visit` in visitors by - ensuring that nested nodes are reported - """ - visitor = self._run_visitor( - """\ -def f(): - x = 1 -""" - ) - self.assertEqual(visitor.typeable_lines, [1, 2]) - self.assertIsInstance(visitor.typeable_nodes[1], ast.FunctionDef) - self.assertIsInstance(visitor.typeable_nodes[2], ast.Assign) - - def test_py35_node_types(self): - """ - Test that the PEP 492 node types are collected - """ - visitor = self._run_visitor( - """\ -async def f(): # async def - async for x in y: pass # async for - async with a as b: pass # async with -""" - ) - self.assertEqual(visitor.typeable_lines, [1, 2, 3]) - self.assertIsInstance(visitor.typeable_nodes[1], ast.AsyncFunctionDef) - self.assertIsInstance(visitor.typeable_nodes[2], ast.AsyncFor) - self.assertIsInstance(visitor.typeable_nodes[3], ast.AsyncWith) - - def test_last_node_wins(self): - """ - Test that when two typeable nodes are present on a line, the last - typeable one wins. - """ - visitor = self._run_visitor('x = 1; y = 1') - # detected both assignable nodes - self.assertEqual(visitor.typeable_lines, [1, 1]) - # but the assignment to `y` wins - self.assertEqual(visitor.typeable_nodes[1].targets[0].id, 'y') - - -class CollectTypeCommentsTests(TestCase): - """ - Tests of L{_collect_type_comments} - """ - - @staticmethod - def _collect(s): - """ - Run L{_collect_type_comments} on the parsed source and return the - mapping from nodes to comments. The return value is converted to - a set: {(node_type, tuple of comments), ...} - """ - tree = ast.parse(s) - tokens = checker.make_tokens(s) - ret = checker._collect_type_comments(tree, tokens) - return {(type(k), tuple(s for _, s in v)) for k, v in ret.items()} - - def test_bytes(self): - """ - Test that the function works for binary source - """ - ret = self._collect(b'x = 1 # type: int') - self.assertSetEqual(ret, {(ast.Assign, ('# type: int',))}) - - def test_text(self): - """ - Test that the function works for text source - """ - ret = self._collect('x = 1 # type: int') - self.assertEqual(ret, {(ast.Assign, ('# type: int',))}) - - def test_non_type_comment_ignored(self): - """ - Test that a non-type comment is ignored - """ - ret = self._collect('x = 1 # noqa') - self.assertSetEqual(ret, set()) - - def test_type_comment_before_typeable(self): - """ - Test that a type comment before something typeable is ignored. - """ - ret = self._collect('# type: int\nx = 1') - self.assertSetEqual(ret, set()) - - def test_type_ignore_comment_ignored(self): - """ - Test that `# type: ignore` comments are not collected. - """ - ret = self._collect('x = 1 # type: ignore') - self.assertSetEqual(ret, set()) - - def test_type_ignore_with_other_things_ignored(self): - """ - Test that `# type: ignore` comments with more content are also not - collected. - """ - ret = self._collect('x = 1 # type: ignore # noqa') - self.assertSetEqual(ret, set()) - ret = self._collect('x = 1 #type:ignore#noqa') - self.assertSetEqual(ret, set()) - - def test_type_comment_with_extra_still_collected(self): - ret = self._collect('x = 1 # type: int # noqa') - self.assertSetEqual(ret, {(ast.Assign, ('# type: int # noqa',))}) - - def test_type_comment_without_whitespace(self): - ret = self._collect('x = 1 #type:int') - self.assertSetEqual(ret, {(ast.Assign, ('#type:int',))}) - - def test_type_comment_starts_with_word_ignore(self): - ret = self._collect('x = 1 # type: ignore[T]') - self.assertSetEqual(ret, set()) - - def test_last_node_wins(self): - """ - Test that when two typeable nodes are present on a line, the last - typeable one wins. - """ - ret = self._collect('def f(): x = 1 # type: int') - self.assertSetEqual(ret, {(ast.Assign, ('# type: int',))}) - - def test_function_def_assigned_comments(self): - """ - Test that type comments for function arguments are all attributed to - the function definition. - """ - ret = self._collect( - """\ -def f( - a, # type: int - b, # type: str -): - # type: (...) -> None - pass -""" - ) - expected = {( - ast.FunctionDef, - ('# type: int', '# type: str', '# type: (...) -> None'), - )} - self.assertSetEqual(ret, expected) |