from .. import abc from .. import util machinery = util.import_importlib('importlib.machinery') from test.support import captured_stdout import types import unittest import warnings class ExecModuleTests(abc.LoaderTests): def exec_module(self, name): with util.uncache(name), captured_stdout() as stdout: spec = self.machinery.ModuleSpec( name, self.machinery.FrozenImporter, origin='frozen', is_package=self.machinery.FrozenImporter.is_package(name)) module = types.ModuleType(name) module.__spec__ = spec assert not hasattr(module, 'initialized') self.machinery.FrozenImporter.exec_module(module) self.assertTrue(module.initialized) self.assertTrue(hasattr(module, '__spec__')) self.assertEqual(module.__spec__.origin, 'frozen') return module, stdout.getvalue() def test_module(self): name = '__hello__' module, output = self.exec_module(name) check = {'__name__': name} for attr, value in check.items(): self.assertEqual(getattr(module, attr), value) self.assertEqual(output, 'Hello world!\n') self.assertTrue(hasattr(module, '__spec__')) def test_package(self): name = '__phello__' module, output = self.exec_module(name) check = {'__name__': name} for attr, value in check.items(): attr_value = getattr(module, attr) self.assertEqual(attr_value, value, 'for {name}.{attr}, {given!r} != {expected!r}'.format( name=name, attr=attr, given=attr_value, expected=value)) self.assertEqual(output, 'Hello world!\n') def test_lacking_parent(self): name = '__phello__.spam' with util.uncache('__phello__'): module, output = self.exec_module(name) check = {'__name__': name} for attr, value in check.items(): attr_value = getattr(module, attr) self.assertEqual(attr_value, value, 'for {name}.{attr}, {given} != {expected!r}'.format( name=name, attr=attr, given=attr_value, expected=value)) self.assertEqual(output, 'Hello world!\n') def test_module_repr(self): name = '__hello__' module, output = self.exec_module(name) with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) repr_str = self.machinery.FrozenImporter.module_repr(module) self.assertEqual(repr_str, "") def test_module_repr_indirect(self): name = '__hello__' module, output = self.exec_module(name) self.assertEqual(repr(module), "") # No way to trigger an error in a frozen module. test_state_after_failure = None def test_unloadable(self): assert self.machinery.FrozenImporter.find_module('_not_real') is None with self.assertRaises(ImportError) as cm: self.exec_module('_not_real') self.assertEqual(cm.exception.name, '_not_real') (Frozen_ExecModuleTests, Source_ExecModuleTests ) = util.test_both(ExecModuleTests, machinery=machinery) class LoaderTests(abc.LoaderTests): def test_module(self): with util.uncache('__hello__'), captured_stdout() as stdout: with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) module = self.machinery.FrozenImporter.load_module('__hello__') check = {'__name__': '__hello__', '__package__': '', '__loader__': self.machinery.FrozenImporter, } for attr, value in check.items(): self.assertEqual(getattr(module, attr), value) self.assertEqual(stdout.getvalue(), 'Hello world!\n') self.assertFalse(hasattr(module, '__file__')) def test_package(self): with util.uncache('__phello__'), captured_stdout() as stdout: with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) module = self.machinery.FrozenImporter.load_module('__phello__') check = {'__name__': '__phello__', '__package__': '__phello__', '__path__': [], '__loader__': self.machinery.FrozenImporter, } for attr, value in check.items(): attr_value = getattr(module, attr) self.assertEqual(attr_value, value, "for __phello__.%s, %r != %r" % (attr, attr_value, value)) self.assertEqual(stdout.getvalue(), 'Hello world!\n') self.assertFalse(hasattr(module, '__file__')) def test_lacking_parent(self): with util.uncache('__phello__', '__phello__.spam'), \ captured_stdout() as stdout: with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) module = self.machinery.FrozenImporter.load_module('__phello__.spam') check = {'__name__': '__phello__.spam', '__package__': '__phello__', '__loader__': self.machinery.FrozenImporter, } for attr, value in check.items(): attr_value = getattr(module, attr) self.assertEqual(attr_value, value, "for __phello__.spam.%s, %r != %r" % (attr, attr_value, value)) self.assertEqual(stdout.getvalue(), 'Hello world!\n') self.assertFalse(hasattr(module, '__file__')) def test_module_reuse(self): with util.uncache('__hello__'), captured_stdout() as stdout: with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) module1 = self.machinery.FrozenImporter.load_module('__hello__') module2 = self.machinery.FrozenImporter.load_module('__hello__') self.assertIs(module1, module2) self.assertEqual(stdout.getvalue(), 'Hello world!\nHello world!\n') def test_module_repr(self): with util.uncache('__hello__'), captured_stdout(): with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) module = self.machinery.FrozenImporter.load_module('__hello__') repr_str = self.machinery.FrozenImporter.module_repr(module) self.assertEqual(repr_str, "") def test_module_repr_indirect(self): with util.uncache('__hello__'), captured_stdout(): module = self.machinery.FrozenImporter.load_module('__hello__') self.assertEqual(repr(module), "") # No way to trigger an error in a frozen module. test_state_after_failure = None def test_unloadable(self): assert self.machinery.FrozenImporter.find_module('_not_real') is None with self.assertRaises(ImportError) as cm: self.machinery.FrozenImporter.load_module('_not_real') self.assertEqual(cm.exception.name, '_not_real') (Frozen_LoaderTests, Source_LoaderTests ) = util.test_both(LoaderTests, machinery=machinery) class InspectLoaderTests: """Tests for the InspectLoader methods for FrozenImporter.""" def test_get_code(self): # Make sure that the code object is good. name = '__hello__' with captured_stdout() as stdout: code = self.machinery.FrozenImporter.get_code(name) mod = types.ModuleType(name) exec(code, mod.__dict__) self.assertTrue(hasattr(mod, 'initialized')) self.assertEqual(stdout.getvalue(), 'Hello world!\n') def test_get_source(self): # Should always return None. result = self.machinery.FrozenImporter.get_source('__hello__') self.assertIsNone(result) def test_is_package(self): # Should be able to tell what is a package. test_for = (('__hello__', False), ('__phello__', True), ('__phello__.spam', False)) for name, is_package in test_for: result = self.machinery.FrozenImporter.is_package(name) self.assertEqual(bool(result), is_package) def test_failure(self): # Raise ImportError for modules that are not frozen. for meth_name in ('get_code', 'get_source', 'is_package'): method = getattr(self.machinery.FrozenImporter, meth_name) with self.assertRaises(ImportError) as cm: method('importlib') self.assertEqual(cm.exception.name, 'importlib') (Frozen_ILTests, Source_ILTests ) = util.test_both(InspectLoaderTests, machinery=machinery) if __name__ == '__main__': unittest.main()