summaryrefslogtreecommitdiffstats
path: root/Lib/importlib/test/test_api.py
diff options
context:
space:
mode:
authorBrett Cannon <brett@python.org>2012-07-20 18:48:53 (GMT)
committerBrett Cannon <brett@python.org>2012-07-20 18:48:53 (GMT)
commit45a5e3afe52ed89f298242143c5f7e2bb992ac63 (patch)
tree2255a23f991f1452335d865939f6c30d7b2d7d48 /Lib/importlib/test/test_api.py
parent4afc1c08d04a9c083b654178ea4f947563510836 (diff)
downloadcpython-45a5e3afe52ed89f298242143c5f7e2bb992ac63.zip
cpython-45a5e3afe52ed89f298242143c5f7e2bb992ac63.tar.gz
cpython-45a5e3afe52ed89f298242143c5f7e2bb992ac63.tar.bz2
Issue #15168: Move importlb.test to test.test_importlib.
This should make the Linux distros happy as it is now easier to leave importlib's tests out of their base Python distribution.
Diffstat (limited to 'Lib/importlib/test/test_api.py')
-rw-r--r--Lib/importlib/test/test_api.py183
1 files changed, 0 insertions, 183 deletions
diff --git a/Lib/importlib/test/test_api.py b/Lib/importlib/test/test_api.py
deleted file mode 100644
index ba2a721..0000000
--- a/Lib/importlib/test/test_api.py
+++ /dev/null
@@ -1,183 +0,0 @@
-from . import util
-import imp
-import importlib
-from importlib import machinery
-import sys
-from test import support
-import unittest
-
-
-class ImportModuleTests(unittest.TestCase):
-
- """Test importlib.import_module."""
-
- def test_module_import(self):
- # Test importing a top-level module.
- with util.mock_modules('top_level') as mock:
- with util.import_state(meta_path=[mock]):
- module = importlib.import_module('top_level')
- self.assertEqual(module.__name__, 'top_level')
-
- def test_absolute_package_import(self):
- # Test importing a module from a package with an absolute name.
- pkg_name = 'pkg'
- pkg_long_name = '{0}.__init__'.format(pkg_name)
- name = '{0}.mod'.format(pkg_name)
- with util.mock_modules(pkg_long_name, name) as mock:
- with util.import_state(meta_path=[mock]):
- module = importlib.import_module(name)
- self.assertEqual(module.__name__, name)
-
- def test_shallow_relative_package_import(self):
- # Test importing a module from a package through a relative import.
- pkg_name = 'pkg'
- pkg_long_name = '{0}.__init__'.format(pkg_name)
- module_name = 'mod'
- absolute_name = '{0}.{1}'.format(pkg_name, module_name)
- relative_name = '.{0}'.format(module_name)
- with util.mock_modules(pkg_long_name, absolute_name) as mock:
- with util.import_state(meta_path=[mock]):
- importlib.import_module(pkg_name)
- module = importlib.import_module(relative_name, pkg_name)
- self.assertEqual(module.__name__, absolute_name)
-
- def test_deep_relative_package_import(self):
- modules = ['a.__init__', 'a.b.__init__', 'a.c']
- with util.mock_modules(*modules) as mock:
- with util.import_state(meta_path=[mock]):
- importlib.import_module('a')
- importlib.import_module('a.b')
- module = importlib.import_module('..c', 'a.b')
- self.assertEqual(module.__name__, 'a.c')
-
- def test_absolute_import_with_package(self):
- # Test importing a module from a package with an absolute name with
- # the 'package' argument given.
- pkg_name = 'pkg'
- pkg_long_name = '{0}.__init__'.format(pkg_name)
- name = '{0}.mod'.format(pkg_name)
- with util.mock_modules(pkg_long_name, name) as mock:
- with util.import_state(meta_path=[mock]):
- importlib.import_module(pkg_name)
- module = importlib.import_module(name, pkg_name)
- self.assertEqual(module.__name__, name)
-
- def test_relative_import_wo_package(self):
- # Relative imports cannot happen without the 'package' argument being
- # set.
- with self.assertRaises(TypeError):
- importlib.import_module('.support')
-
-
- def test_loaded_once(self):
- # Issue #13591: Modules should only be loaded once when
- # initializing the parent package attempts to import the
- # module currently being imported.
- b_load_count = 0
- def load_a():
- importlib.import_module('a.b')
- def load_b():
- nonlocal b_load_count
- b_load_count += 1
- code = {'a': load_a, 'a.b': load_b}
- modules = ['a.__init__', 'a.b']
- with util.mock_modules(*modules, module_code=code) as mock:
- with util.import_state(meta_path=[mock]):
- importlib.import_module('a.b')
- self.assertEqual(b_load_count, 1)
-
-
-class FindLoaderTests(unittest.TestCase):
-
- class FakeMetaFinder:
- @staticmethod
- def find_module(name, path=None): return name, path
-
- def test_sys_modules(self):
- # If a module with __loader__ is in sys.modules, then return it.
- name = 'some_mod'
- with util.uncache(name):
- module = imp.new_module(name)
- loader = 'a loader!'
- module.__loader__ = loader
- sys.modules[name] = module
- found = importlib.find_loader(name)
- self.assertEqual(loader, found)
-
- def test_sys_modules_loader_is_None(self):
- # If sys.modules[name].__loader__ is None, raise ValueError.
- name = 'some_mod'
- with util.uncache(name):
- module = imp.new_module(name)
- module.__loader__ = None
- sys.modules[name] = module
- with self.assertRaises(ValueError):
- importlib.find_loader(name)
-
- def test_success(self):
- # Return the loader found on sys.meta_path.
- name = 'some_mod'
- with util.uncache(name):
- with util.import_state(meta_path=[self.FakeMetaFinder]):
- self.assertEqual((name, None), importlib.find_loader(name))
-
- def test_success_path(self):
- # Searching on a path should work.
- name = 'some_mod'
- path = 'path to some place'
- with util.uncache(name):
- with util.import_state(meta_path=[self.FakeMetaFinder]):
- self.assertEqual((name, path),
- importlib.find_loader(name, path))
-
- def test_nothing(self):
- # None is returned upon failure to find a loader.
- self.assertIsNone(importlib.find_loader('nevergoingtofindthismodule'))
-
-
-class InvalidateCacheTests(unittest.TestCase):
-
- def test_method_called(self):
- # If defined the method should be called.
- class InvalidatingNullFinder:
- def __init__(self, *ignored):
- self.called = False
- def find_module(self, *args):
- return None
- def invalidate_caches(self):
- self.called = True
-
- key = 'gobledeegook'
- ins = InvalidatingNullFinder()
- sys.path_importer_cache[key] = ins
- self.addCleanup(lambda: sys.path_importer_cache.__delitem__(key))
- importlib.invalidate_caches()
- self.assertTrue(ins.called)
-
- def test_method_lacking(self):
- # There should be no issues if the method is not defined.
- key = 'gobbledeegook'
- sys.path_importer_cache[key] = imp.NullImporter('abc')
- self.addCleanup(lambda: sys.path_importer_cache.__delitem__(key))
- importlib.invalidate_caches() # Shouldn't trigger an exception.
-
-
-class FrozenImportlibTests(unittest.TestCase):
-
- def test_no_frozen_importlib(self):
- # Should be able to import w/o _frozen_importlib being defined.
- module = support.import_fresh_module('importlib', blocked=['_frozen_importlib'])
- self.assertFalse(isinstance(module.__loader__,
- machinery.FrozenImporter))
-
-
-def test_main():
- from test.support import run_unittest
- run_unittest(ImportModuleTests,
- FindLoaderTests,
- InvalidateCacheTests,
- FrozenImportlibTests)
-
-
-if __name__ == '__main__':
- test_main()