diff options
Diffstat (limited to 'Lib/test/test_importlib/builtin')
| -rw-r--r-- | Lib/test/test_importlib/builtin/__init__.py | 12 | ||||
| -rw-r--r-- | Lib/test/test_importlib/builtin/test_finder.py | 55 | ||||
| -rw-r--r-- | Lib/test/test_importlib/builtin/test_loader.py | 105 | ||||
| -rw-r--r-- | Lib/test/test_importlib/builtin/util.py | 7 |
4 files changed, 179 insertions, 0 deletions
diff --git a/Lib/test/test_importlib/builtin/__init__.py b/Lib/test/test_importlib/builtin/__init__.py new file mode 100644 index 00000000000..15c0ade207e --- /dev/null +++ b/Lib/test/test_importlib/builtin/__init__.py @@ -0,0 +1,12 @@ +from .. import test_suite +import os + + +def test_suite(): + directory = os.path.dirname(__file__) + return test_suite('importlib.test.builtin', directory) + + +if __name__ == '__main__': + from test.support import run_unittest + run_unittest(test_suite()) diff --git a/Lib/test/test_importlib/builtin/test_finder.py b/Lib/test/test_importlib/builtin/test_finder.py new file mode 100644 index 00000000000..146538d891d --- /dev/null +++ b/Lib/test/test_importlib/builtin/test_finder.py @@ -0,0 +1,55 @@ +from importlib import machinery +from .. import abc +from .. import util +from . import util as builtin_util + +import sys +import unittest + +class FinderTests(abc.FinderTests): + + """Test find_module() for built-in modules.""" + + def test_module(self): + # Common case. + with util.uncache(builtin_util.NAME): + found = machinery.BuiltinImporter.find_module(builtin_util.NAME) + self.assertTrue(found) + + def test_package(self): + # Built-in modules cannot be a package. + pass + + def test_module_in_package(self): + # Built-in modules cannobt be in a package. + pass + + def test_package_in_package(self): + # Built-in modules cannot be a package. + pass + + def test_package_over_module(self): + # Built-in modules cannot be a package. + pass + + def test_failure(self): + assert 'importlib' not in sys.builtin_module_names + loader = machinery.BuiltinImporter.find_module('importlib') + self.assertIsNone(loader) + + def test_ignore_path(self): + # The value for 'path' should always trigger a failed import. + with util.uncache(builtin_util.NAME): + loader = machinery.BuiltinImporter.find_module(builtin_util.NAME, + ['pkg']) + self.assertIsNone(loader) + + + +def test_main(): + from test.support import run_unittest + run_unittest(FinderTests) + + +if __name__ == '__main__': + test_main() diff --git a/Lib/test/test_importlib/builtin/test_loader.py b/Lib/test/test_importlib/builtin/test_loader.py new file mode 100644 index 00000000000..8e186e71560 --- /dev/null +++ b/Lib/test/test_importlib/builtin/test_loader.py @@ -0,0 +1,105 @@ +import importlib +from importlib import machinery +from .. import abc +from .. import util +from . import util as builtin_util + +import sys +import types +import unittest + + +class LoaderTests(abc.LoaderTests): + + """Test load_module() for built-in modules.""" + + verification = {'__name__': 'errno', '__package__': '', + '__loader__': machinery.BuiltinImporter} + + def verify(self, module): + """Verify that the module matches against what it should have.""" + self.assertIsInstance(module, types.ModuleType) + for attr, value in self.verification.items(): + self.assertEqual(getattr(module, attr), value) + self.assertIn(module.__name__, sys.modules) + + load_module = staticmethod(lambda name: + machinery.BuiltinImporter.load_module(name)) + + def test_module(self): + # Common case. + with util.uncache(builtin_util.NAME): + module = self.load_module(builtin_util.NAME) + self.verify(module) + + def test_package(self): + # Built-in modules cannot be a package. + pass + + def test_lacking_parent(self): + # Built-in modules cannot be a package. + pass + + def test_state_after_failure(self): + # Not way to force an imoprt failure. + pass + + def test_module_reuse(self): + # Test that the same module is used in a reload. + with util.uncache(builtin_util.NAME): + module1 = self.load_module(builtin_util.NAME) + module2 = self.load_module(builtin_util.NAME) + self.assertIs(module1, module2) + + def test_unloadable(self): + name = 'dssdsdfff' + assert name not in sys.builtin_module_names + with self.assertRaises(ImportError) as cm: + self.load_module(name) + self.assertEqual(cm.exception.name, name) + + def test_already_imported(self): + # Using the name of a module already imported but not a built-in should + # still fail. + assert hasattr(importlib, '__file__') # Not a built-in. + with self.assertRaises(ImportError) as cm: + self.load_module('importlib') + self.assertEqual(cm.exception.name, 'importlib') + + +class InspectLoaderTests(unittest.TestCase): + + """Tests for InspectLoader methods for BuiltinImporter.""" + + def test_get_code(self): + # There is no code object. + result = machinery.BuiltinImporter.get_code(builtin_util.NAME) + self.assertIsNone(result) + + def test_get_source(self): + # There is no source. + result = machinery.BuiltinImporter.get_source(builtin_util.NAME) + self.assertIsNone(result) + + def test_is_package(self): + # Cannot be a package. + result = machinery.BuiltinImporter.is_package(builtin_util.NAME) + self.assertTrue(not result) + + def test_not_builtin(self): + # Modules not built-in should raise ImportError. + for meth_name in ('get_code', 'get_source', 'is_package'): + method = getattr(machinery.BuiltinImporter, meth_name) + with self.assertRaises(ImportError) as cm: + method(builtin_util.BAD_NAME) + self.assertRaises(builtin_util.BAD_NAME) + + + +def test_main(): + from test.support import run_unittest + run_unittest(LoaderTests, InspectLoaderTests) + + +if __name__ == '__main__': + test_main() diff --git a/Lib/test/test_importlib/builtin/util.py b/Lib/test/test_importlib/builtin/util.py new file mode 100644 index 00000000000..5704699ee23 --- /dev/null +++ b/Lib/test/test_importlib/builtin/util.py @@ -0,0 +1,7 @@ +import sys + +assert 'errno' in sys.builtin_module_names +NAME = 'errno' + +assert 'importlib' not in sys.builtin_module_names +BAD_NAME = 'importlib' |