def test_attributes_set(self): # __name__, __loader__, and __package__ should be set (when # is_package() is defined; undefined implicitly tested elsewhere). class FakeLoader: def __init__(self, is_package): self._pkg = is_package def is_package(self, name): return self._pkg @self.module_for_loader def load_module(self, module): return module name = 'pkg.mod' with util.uncache(name): loader = FakeLoader(False) module = loader.load_module(name) self.assertEqual(module.__name__, name) self.assertIs(module.__loader__, loader) self.assertEqual(module.__package__, 'pkg') name = 'pkg.sub' with util.uncache(name): loader = FakeLoader(True) module = loader.load_module(name) self.assertEqual(module.__name__, name) self.assertIs(module.__loader__, loader) self.assertEqual(module.__package__, name)
def test_reload(self): # Test that reload didn't re-set the module's attributes. with util.uncache(self.name): module = self.load_module() ex_class = module.Example importlib.reload(module) self.assertIs(ex_class, module.Example)
def test_new_module_failure(self): # Test that a module is removed from sys.modules if added but an # exception is raised. name = 'a.b.c' with util.uncache(name): self.raise_exception(name) self.assertNotIn(name, sys.modules)
def test_module(self): # Common case. with util.uncache(util.BUILTINS.good_name): found = self.machinery.BuiltinImporter.find_spec( util.BUILTINS.good_name) self.assertTrue(found) self.assertEqual(found.origin, 'built-in')
def test_using_cache(self): # [use cache] module_to_use = "some module found!" with util.uncache('some_module'): sys.modules['some_module'] = module_to_use module = self.__import__('some_module') self.assertEqual(id(module_to_use), id(module))
def test_import_from_non_package(self): path = os.path.join(os.path.dirname(__file__), 'data', 'package2') with uncache('submodule1', 'submodule2'), DirsOnSysPath(path): with self.assertRaises(ImportError): import submodule1 self.assertNotIn('submodule1', sys.modules) self.assertNotIn('submodule2', sys.modules)
def test_import_from_non_package(self): path = os.path.join(os.path.dirname(__file__), 'data', 'package2') with uncache('submodule1', 'submodule2'), DirsOnSysPath(path): with self.assertRaises(ImportError): import submodule1 self.assertNotIn('submodule1', sys.modules) self.assertNotIn('submodule2', sys.modules)
def test_module_substitution_error(self): with test_util.uncache(TestingImporter.module_name): fresh_module = types.ModuleType(TestingImporter.module_name) sys.modules[TestingImporter.module_name] = fresh_module module = self.new_module() with self.assertRaisesRegex(ValueError, "substituted"): module.__name__
def test_reload_namespace_changed(self): name = 'spam' with os_helper.temp_cwd(None) as cwd: with test_util.uncache('spam'): with import_helper.DirsOnSysPath(cwd): # Start as a namespace package. self.init.invalidate_caches() bad_path = os.path.join(cwd, name, '__init.py') cached = self.util.cache_from_source(bad_path) expected = { '__name__': name, '__package__': name, '__doc__': None, '__file__': None, } os.mkdir(name) with open(bad_path, 'w', encoding='utf-8') as init_file: init_file.write('eggs = None') module = self.init.import_module(name) ns = vars(module).copy() loader = ns.pop('__loader__') path = ns.pop('__path__') spec = ns.pop('__spec__') ns.pop('__builtins__', None) # An implementation detail. self.assertEqual(spec.name, name) self.assertIsNotNone(spec.loader) self.assertIsNotNone(loader) self.assertEqual(spec.loader, loader) self.assertEqual(set(path), set([os.path.dirname(bad_path)])) with self.assertRaises(AttributeError): # a NamespaceLoader loader.path self.assertEqual(ns, expected) # Change to a regular package. self.init.invalidate_caches() init_path = os.path.join(cwd, name, '__init__.py') cached = self.util.cache_from_source(init_path) expected = { '__name__': name, '__package__': name, '__file__': init_path, '__cached__': cached, '__path__': [os.path.dirname(init_path)], '__doc__': None, 'eggs': None, } os.rename(bad_path, init_path) reloaded = self.init.reload(module) ns = vars(reloaded).copy() loader = ns.pop('__loader__') spec = ns.pop('__spec__') ns.pop('__builtins__', None) # An implementation detail. self.assertEqual(spec.name, name) self.assertEqual(spec.loader, loader) self.assertIs(reloaded, module) self.assertEqual(loader.path, init_path) self.assertEqual(ns, expected)
def test_sys_modules_spec_is_None(self): name = 'some_mod' with util.uncache(name): module = types.ModuleType(name) module.__spec__ = None sys.modules[name] = module with self.assertRaises(ValueError): self.util.find_spec(name)
def test_None_in_cache(self): #[None in cache] name = 'using_None' with util.uncache(name): sys.modules[name] = None with self.assertRaises(ImportError) as cm: self.__import__(name) self.assertEqual(cm.exception.name, name)
def test_ignore_path(self): # The value for 'path' should always trigger a failed import. with util.uncache(util.BUILTINS.good_name): with warnings.catch_warnings(): warnings.simplefilter("ignore", DeprecationWarning) loader = self.machinery.BuiltinImporter.find_module( util.BUILTINS.good_name, ['pkg']) self.assertIsNone(loader)
def test_reload_failure(self): # Test that a failure on reload leaves the module in-place. name = 'a.b.c' module = types.ModuleType(name) with util.uncache(name): sys.modules[name] = module self.raise_exception(name) self.assertIs(module, sys.modules[name])
def fresh(name, *, oldapi=False): with util.uncache(name): with import_helper.frozen_modules(): if oldapi: with deprecated(): yield else: yield
def test_success(self): # Return the loader found on sys.meta_path. name = 'some_mod' with test_util.uncache(name): with test_util.import_state(meta_path=[self.FakeMetaFinder]): with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) warnings.simplefilter('ignore', ImportWarning) self.assertEqual((name, None), self.init.find_loader(name))
def test_module(self): # Common case. with util.uncache(util.BUILTINS.good_name): with warnings.catch_warnings(): warnings.simplefilter("ignore", DeprecationWarning) found = self.machinery.BuiltinImporter.find_module( util.BUILTINS.good_name) self.assertTrue(found) self.assertTrue(hasattr(found, 'load_module'))
def from_cache(seconds, repeat): """sys.modules""" name = '<benchmark import>' module = imp.new_module(name) module.__file__ = '<test>' module.__package__ = '' with util.uncache(name): sys.modules[name] = module yield from bench(name, repeat=repeat, seconds=seconds)
def test_new_module(self): # Test that when no module exists in sys.modules a new module is # created. module_name = 'a.b.c' with util.uncache(module_name): module = self.return_module(module_name) self.assertIn(module_name, sys.modules) self.assertIsInstance(module, types.ModuleType) self.assertEqual(module.__name__, module_name)
def test_nonexistent_fromlist_entry(self): # If something in fromlist doesn't exist, that's okay. # issue15715 mod = types.ModuleType(PKG_NAME) mod.__path__ = ['XXX'] with util.import_state(meta_path=[self.bad_finder_loader]): with util.uncache(PKG_NAME): sys.modules[PKG_NAME] = mod self.__import__(PKG_NAME, fromlist=['not here'])
def test_sys_modules_loader_is_None(self): name = 'some_mod' with util.uncache(name): module = types.ModuleType(name) spec = self.machinery.ModuleSpec(name, None) module.__spec__ = spec sys.modules[name] = module found = self.util.find_spec(name) self.assertEqual(found, spec)
def from_cache(seconds, repeat): """sys.modules""" name = '<benchmark import>' module = imp.new_module(name) module.__file__ = '<test>' module.__package__ = '' with util.uncache(name): sys.modules[name] = module yield from bench(name, repeat=repeat, seconds=seconds)
def test_module(self): with util.uncache(util.EXTENSIONS.name): module = self.load_module(util.EXTENSIONS.name) for attr, value in [('__name__', util.EXTENSIONS.name), ('__file__', util.EXTENSIONS.file_path), ('__package__', '')]: self.assertEqual(getattr(module, attr), value) self.assertIn(util.EXTENSIONS.name, sys.modules) self.assertIsInstance(module.__loader__, self.machinery.ExtensionFileLoader)
def from_cache(seconds, repeat): """sys.modules""" name = "<benchmark import>" module = imp.new_module(name) module.__file__ = "<test>" module.__package__ = "" with util.uncache(name): sys.modules[name] = module for result in bench(name, repeat=repeat, seconds=seconds): yield result
def test___loader___is_None(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", ImportWarning) module = types.ModuleType('blah') module.__loader__ = None loader = LoaderMock() loader.module = module with util.uncache('blah'), util.import_state(meta_path=[loader]): returned_module = self.__import__('blah') self.assertEqual(loader, module.__loader__)
def test_already_imported(self): # Using the name of a module already imported but not a built-in should # still fail. module_name = 'builtin_reload_test' assert module_name not in sys.builtin_module_names with util.uncache(module_name): module = types.ModuleType(module_name) sys.modules[module_name] = module with self.assertRaises(ImportError) as cm: self.load_module(module_name) self.assertEqual(cm.exception.name, module_name)
def test_sys_modules_without___loader__(self): name = 'some_mod' with util.uncache(name): module = types.ModuleType(name) del module.__loader__ loader = 'a loader!' spec = self.machinery.ModuleSpec(name, loader) module.__spec__ = spec sys.modules[name] = module found = self.util.find_spec(name) self.assertEqual(found, spec)
def test_sys_modules_spec_is_not_set(self): name = 'some_mod' with util.uncache(name): module = types.ModuleType(name) try: del module.__spec__ except AttributeError: pass sys.modules[name] = module with self.assertRaises(ValueError): self.util.find_spec(name)
def test_success_path(self): # Searching on a path should work. name = 'some_mod' path = 'path to some place' with test_util.uncache(name): with test_util.import_state(meta_path=[self.FakeMetaFinder]): with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) warnings.simplefilter('ignore', ImportWarning) self.assertEqual((name, path), self.init.find_loader(name, path))
def test_module_missing_spec(self): #Test that reload() throws ModuleNotFounderror when reloading # a module whose missing a spec. (bpo-29851) name = 'spam' with test_util.uncache(name): module = sys.modules[name] = types.ModuleType(name) # Sanity check by attempting an import. module = self.init.import_module(name) self.assertIsNone(module.__spec__) with self.assertRaises(ModuleNotFoundError): self.init.reload(module)
def test_sys_modules_loader_is_None(self): # If sys.modules[name].__loader__ is None, raise ValueError. name = 'some_mod' with test_util.uncache(name): module = types.ModuleType(name) module.__loader__ = None sys.modules[name] = module with self.assertRaises(ValueError): with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) self.init.find_loader(name)
def test_e2e(self): # End-to-end test to verify the load is in fact lazy. importer = TestingImporter() assert importer.loaded is None with test_util.uncache(importer.module_name): with test_util.import_state(meta_path=[importer]): module = importlib.import_module(importer.module_name) self.assertIsNone(importer.loaded) # Trigger load. self.assertEqual(module.__loader__, importer) self.assertIsNotNone(importer.loaded) self.assertEqual(module, importer.loaded)
def test_sys_modules(self): # If a module with __loader__ is in sys.modules, then return it. name = 'some_mod' with test_util.uncache(name): module = types.ModuleType(name) loader = 'a loader!' module.__loader__ = loader sys.modules[name] = module with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) found = self.init.find_loader(name) self.assertEqual(loader, found)
def test_fromlist_load_error_propagates(self): # If something in fromlist triggers an exception not related to not # existing, let that exception propagate. # issue15316 mod = types.ModuleType(PKG_NAME) mod.__path__ = ['XXX'] with util.import_state(meta_path=[self.bad_finder_loader]): with util.uncache(PKG_NAME): sys.modules[PKG_NAME] = mod with self.assertRaises(ImportError): self.__import__(PKG_NAME, fromlist=[SUBMOD_NAME.rpartition('.')[-1]])
def test_import_from_unloaded_package(self): with uncache('package2', 'package2.submodule1', 'package2.submodule2'), \ DirsOnSysPath(os.path.join(os.path.dirname(__file__), 'data')): import package2.submodule1 package2.submodule1.submodule2