313 lines
12 KiB
Python
313 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Copyright (c) 2006, 2009-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
|
|
# Copyright (c) 2013 AndroWiiid <androwiiid@gmail.com>
|
|
# Copyright (c) 2014-2019 Claudiu Popa <pcmanticore@gmail.com>
|
|
# Copyright (c) 2014 Google, Inc.
|
|
# Copyright (c) 2015-2016 Ceridwen <ceridwenv@gmail.com>
|
|
# Copyright (c) 2017 Chris Philip <chrisp533@gmail.com>
|
|
# Copyright (c) 2017 Hugo <hugovk@users.noreply.github.com>
|
|
# Copyright (c) 2017 ioanatia <ioanatia@users.noreply.github.com>
|
|
# Copyright (c) 2018 Ville Skyttä <ville.skytta@iki.fi>
|
|
# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
|
|
# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
|
|
# Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com>
|
|
# Copyright (c) 2020 Anubhav <35621759+anubh-v@users.noreply.github.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
|
|
|
|
import os
|
|
import platform
|
|
import site
|
|
import sys
|
|
import unittest
|
|
|
|
import pkg_resources
|
|
import six
|
|
import time
|
|
|
|
import astroid
|
|
from astroid import exceptions
|
|
from astroid import manager
|
|
from . import resources
|
|
|
|
|
|
BUILTINS = six.moves.builtins.__name__
|
|
|
|
|
|
def _get_file_from_object(obj):
|
|
if platform.python_implementation() == "Jython":
|
|
return obj.__file__.split("$py.class")[0] + ".py"
|
|
return obj.__file__
|
|
|
|
|
|
class AstroidManagerTest(
|
|
resources.SysPathSetup, resources.AstroidCacheSetupMixin, unittest.TestCase
|
|
):
|
|
def setUp(self):
|
|
super(AstroidManagerTest, self).setUp()
|
|
self.manager = manager.AstroidManager()
|
|
|
|
def test_ast_from_file(self):
|
|
filepath = unittest.__file__
|
|
ast = self.manager.ast_from_file(filepath)
|
|
self.assertEqual(ast.name, "unittest")
|
|
self.assertIn("unittest", self.manager.astroid_cache)
|
|
|
|
def test_ast_from_file_cache(self):
|
|
filepath = unittest.__file__
|
|
self.manager.ast_from_file(filepath)
|
|
ast = self.manager.ast_from_file("unhandledName", "unittest")
|
|
self.assertEqual(ast.name, "unittest")
|
|
self.assertIn("unittest", self.manager.astroid_cache)
|
|
|
|
def test_ast_from_file_astro_builder(self):
|
|
filepath = unittest.__file__
|
|
ast = self.manager.ast_from_file(filepath, None, True, True)
|
|
self.assertEqual(ast.name, "unittest")
|
|
self.assertIn("unittest", self.manager.astroid_cache)
|
|
|
|
def test_ast_from_file_name_astro_builder_exception(self):
|
|
self.assertRaises(
|
|
exceptions.AstroidBuildingError, self.manager.ast_from_file, "unhandledName"
|
|
)
|
|
|
|
def test_ast_from_string(self):
|
|
filepath = unittest.__file__
|
|
dirname = os.path.dirname(filepath)
|
|
modname = os.path.basename(dirname)
|
|
with open(filepath, "r") as file:
|
|
data = file.read()
|
|
ast = self.manager.ast_from_string(data, modname, filepath)
|
|
self.assertEqual(ast.name, "unittest")
|
|
self.assertEqual(ast.file, filepath)
|
|
self.assertIn("unittest", self.manager.astroid_cache)
|
|
|
|
def test_do_not_expose_main(self):
|
|
obj = self.manager.ast_from_module_name("__main__")
|
|
self.assertEqual(obj.name, "__main__")
|
|
self.assertEqual(obj.items(), [])
|
|
|
|
def test_ast_from_module_name(self):
|
|
ast = self.manager.ast_from_module_name("unittest")
|
|
self.assertEqual(ast.name, "unittest")
|
|
self.assertIn("unittest", self.manager.astroid_cache)
|
|
|
|
def test_ast_from_module_name_not_python_source(self):
|
|
ast = self.manager.ast_from_module_name("time")
|
|
self.assertEqual(ast.name, "time")
|
|
self.assertIn("time", self.manager.astroid_cache)
|
|
self.assertEqual(ast.pure_python, False)
|
|
|
|
def test_ast_from_module_name_astro_builder_exception(self):
|
|
self.assertRaises(
|
|
exceptions.AstroidBuildingError,
|
|
self.manager.ast_from_module_name,
|
|
"unhandledModule",
|
|
)
|
|
|
|
def _test_ast_from_old_namespace_package_protocol(self, root):
|
|
origpath = sys.path[:]
|
|
paths = [
|
|
resources.find("data/path_{}_{}".format(root, index))
|
|
for index in range(1, 4)
|
|
]
|
|
sys.path.extend(paths)
|
|
try:
|
|
for name in ("foo", "bar", "baz"):
|
|
module = self.manager.ast_from_module_name("package." + name)
|
|
self.assertIsInstance(module, astroid.Module)
|
|
finally:
|
|
sys.path = origpath
|
|
|
|
def test_ast_from_namespace_pkgutil(self):
|
|
self._test_ast_from_old_namespace_package_protocol("pkgutil")
|
|
|
|
def test_ast_from_namespace_pkg_resources(self):
|
|
self._test_ast_from_old_namespace_package_protocol("pkg_resources")
|
|
|
|
def test_implicit_namespace_package(self):
|
|
data_dir = os.path.dirname(resources.find("data/namespace_pep_420"))
|
|
contribute = os.path.join(data_dir, "contribute_to_namespace")
|
|
for value in (data_dir, contribute):
|
|
sys.path.insert(0, value)
|
|
|
|
try:
|
|
module = self.manager.ast_from_module_name("namespace_pep_420.module")
|
|
self.assertIsInstance(module, astroid.Module)
|
|
self.assertEqual(module.name, "namespace_pep_420.module")
|
|
var = next(module.igetattr("var"))
|
|
self.assertIsInstance(var, astroid.Const)
|
|
self.assertEqual(var.value, 42)
|
|
finally:
|
|
for _ in range(2):
|
|
sys.path.pop(0)
|
|
|
|
def test_namespace_package_pth_support(self):
|
|
pth = "foogle_fax-0.12.5-py2.7-nspkg.pth"
|
|
site.addpackage(resources.RESOURCE_PATH, pth, [])
|
|
pkg_resources._namespace_packages["foogle"] = []
|
|
|
|
try:
|
|
module = self.manager.ast_from_module_name("foogle.fax")
|
|
submodule = next(module.igetattr("a"))
|
|
value = next(submodule.igetattr("x"))
|
|
self.assertIsInstance(value, astroid.Const)
|
|
with self.assertRaises(exceptions.AstroidImportError):
|
|
self.manager.ast_from_module_name("foogle.moogle")
|
|
finally:
|
|
del pkg_resources._namespace_packages["foogle"]
|
|
sys.modules.pop("foogle")
|
|
|
|
def test_nested_namespace_import(self):
|
|
pth = "foogle_fax-0.12.5-py2.7-nspkg.pth"
|
|
site.addpackage(resources.RESOURCE_PATH, pth, [])
|
|
pkg_resources._namespace_packages["foogle"] = ["foogle.crank"]
|
|
pkg_resources._namespace_packages["foogle.crank"] = []
|
|
try:
|
|
self.manager.ast_from_module_name("foogle.crank")
|
|
finally:
|
|
del pkg_resources._namespace_packages["foogle"]
|
|
sys.modules.pop("foogle")
|
|
|
|
def test_namespace_and_file_mismatch(self):
|
|
filepath = unittest.__file__
|
|
ast = self.manager.ast_from_file(filepath)
|
|
self.assertEqual(ast.name, "unittest")
|
|
pth = "foogle_fax-0.12.5-py2.7-nspkg.pth"
|
|
site.addpackage(resources.RESOURCE_PATH, pth, [])
|
|
pkg_resources._namespace_packages["foogle"] = []
|
|
try:
|
|
with self.assertRaises(exceptions.AstroidImportError):
|
|
self.manager.ast_from_module_name("unittest.foogle.fax")
|
|
finally:
|
|
del pkg_resources._namespace_packages["foogle"]
|
|
sys.modules.pop("foogle")
|
|
|
|
def _test_ast_from_zip(self, archive):
|
|
origpath = sys.path[:]
|
|
sys.modules.pop("mypypa", None)
|
|
archive_path = resources.find(archive)
|
|
sys.path.insert(0, archive_path)
|
|
try:
|
|
module = self.manager.ast_from_module_name("mypypa")
|
|
self.assertEqual(module.name, "mypypa")
|
|
end = os.path.join(archive, "mypypa")
|
|
self.assertTrue(
|
|
module.file.endswith(end), "%s doesn't endswith %s" % (module.file, end)
|
|
)
|
|
finally:
|
|
# remove the module, else after importing egg, we don't get the zip
|
|
if "mypypa" in self.manager.astroid_cache:
|
|
del self.manager.astroid_cache["mypypa"]
|
|
del self.manager._mod_file_cache[("mypypa", None)]
|
|
if archive_path in sys.path_importer_cache:
|
|
del sys.path_importer_cache[archive_path]
|
|
sys.path = origpath
|
|
|
|
def test_ast_from_module_name_egg(self):
|
|
self._test_ast_from_zip(
|
|
os.path.sep.join(["data", os.path.normcase("MyPyPa-0.1.0-py2.5.egg")])
|
|
)
|
|
|
|
def test_ast_from_module_name_zip(self):
|
|
self._test_ast_from_zip(
|
|
os.path.sep.join(["data", os.path.normcase("MyPyPa-0.1.0-py2.5.zip")])
|
|
)
|
|
|
|
def test_zip_import_data(self):
|
|
"""check if zip_import_data works"""
|
|
filepath = resources.find("data/MyPyPa-0.1.0-py2.5.zip/mypypa")
|
|
ast = self.manager.zip_import_data(filepath)
|
|
self.assertEqual(ast.name, "mypypa")
|
|
|
|
def test_zip_import_data_without_zipimport(self):
|
|
"""check if zip_import_data return None without zipimport"""
|
|
self.assertEqual(self.manager.zip_import_data("path"), None)
|
|
|
|
def test_file_from_module(self):
|
|
"""check if the unittest filepath is equals to the result of the method"""
|
|
self.assertEqual(
|
|
_get_file_from_object(unittest),
|
|
self.manager.file_from_module_name("unittest", None).location,
|
|
)
|
|
|
|
def test_file_from_module_name_astro_building_exception(self):
|
|
"""check if the method raises an exception with a wrong module name"""
|
|
self.assertRaises(
|
|
exceptions.AstroidBuildingError,
|
|
self.manager.file_from_module_name,
|
|
"unhandledModule",
|
|
None,
|
|
)
|
|
|
|
def test_ast_from_module(self):
|
|
ast = self.manager.ast_from_module(unittest)
|
|
self.assertEqual(ast.pure_python, True)
|
|
ast = self.manager.ast_from_module(time)
|
|
self.assertEqual(ast.pure_python, False)
|
|
|
|
def test_ast_from_module_cache(self):
|
|
"""check if the module is in the cache manager"""
|
|
ast = self.manager.ast_from_module(unittest)
|
|
self.assertEqual(ast.name, "unittest")
|
|
self.assertIn("unittest", self.manager.astroid_cache)
|
|
|
|
def test_ast_from_class(self):
|
|
ast = self.manager.ast_from_class(int)
|
|
self.assertEqual(ast.name, "int")
|
|
self.assertEqual(ast.parent.frame().name, BUILTINS)
|
|
|
|
ast = self.manager.ast_from_class(object)
|
|
self.assertEqual(ast.name, "object")
|
|
self.assertEqual(ast.parent.frame().name, BUILTINS)
|
|
self.assertIn("__setattr__", ast)
|
|
|
|
def test_ast_from_class_with_module(self):
|
|
"""check if the method works with the module name"""
|
|
ast = self.manager.ast_from_class(int, int.__module__)
|
|
self.assertEqual(ast.name, "int")
|
|
self.assertEqual(ast.parent.frame().name, BUILTINS)
|
|
|
|
ast = self.manager.ast_from_class(object, object.__module__)
|
|
self.assertEqual(ast.name, "object")
|
|
self.assertEqual(ast.parent.frame().name, BUILTINS)
|
|
self.assertIn("__setattr__", ast)
|
|
|
|
def test_ast_from_class_attr_error(self):
|
|
"""give a wrong class at the ast_from_class method"""
|
|
self.assertRaises(
|
|
exceptions.AstroidBuildingError, self.manager.ast_from_class, None
|
|
)
|
|
|
|
def testFailedImportHooks(self):
|
|
def hook(modname):
|
|
if modname == "foo.bar":
|
|
return unittest
|
|
|
|
raise exceptions.AstroidBuildingError()
|
|
|
|
with self.assertRaises(exceptions.AstroidBuildingError):
|
|
self.manager.ast_from_module_name("foo.bar")
|
|
self.manager.register_failed_import_hook(hook)
|
|
self.assertEqual(unittest, self.manager.ast_from_module_name("foo.bar"))
|
|
with self.assertRaises(exceptions.AstroidBuildingError):
|
|
self.manager.ast_from_module_name("foo.bar.baz")
|
|
del self.manager._failed_import_hooks[0]
|
|
|
|
|
|
class BorgAstroidManagerTC(unittest.TestCase):
|
|
def test_borg(self):
|
|
"""test that the AstroidManager is really a borg, i.e. that two different
|
|
instances has same cache"""
|
|
first_manager = manager.AstroidManager()
|
|
built = first_manager.ast_from_module_name(BUILTINS)
|
|
|
|
second_manager = manager.AstroidManager()
|
|
second_built = second_manager.ast_from_module_name(BUILTINS)
|
|
self.assertIs(built, second_built)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|