cpython/Lib/importlib/test/import_/test_packages.py

from .. import util
from . import util as import_util
import sys
import unittest
import importlib
from test import support


class ParentModuleTests(unittest.TestCase):

    """Importing a submodule should import the parent modules."""

    def test_import_parent(self):
        with util.mock_modules('pkg.__init__', 'pkg.module') as mock:
            with util.import_state(meta_path=[mock]):
                module = import_util.import_('pkg.module')
                self.assertTrue('pkg' in sys.modules)

    def test_bad_parent(self):
        with util.mock_modules('pkg.module') as mock:
            with util.import_state(meta_path=[mock]):
                with self.assertRaises(ImportError) as cm:
                    import_util.import_('pkg.module')
                self.assertEqual(cm.exception.name, 'pkg')

    def test_raising_parent_after_importing_child(self):
        def __init__():
            import pkg.module
            1/0
        mock = util.mock_modules('pkg.__init__', 'pkg.module',
                                 module_code={'pkg': __init__})
        with mock:
            with util.import_state(meta_path=[mock]):
                with self.assertRaises(ZeroDivisionError):
                    import_util.import_('pkg')
                self.assertFalse('pkg' in sys.modules)
                self.assertTrue('pkg.module' in sys.modules)
                with self.assertRaises(ZeroDivisionError):
                    import_util.import_('pkg.module')
                self.assertFalse('pkg' in sys.modules)
                self.assertTrue('pkg.module' in sys.modules)

    def test_raising_parent_after_relative_importing_child(self):
        def __init__():
            from . import module
            1/0
        mock = util.mock_modules('pkg.__init__', 'pkg.module',
                                 module_code={'pkg': __init__})
        with mock:
            with util.import_state(meta_path=[mock]):
                with self.assertRaises((ZeroDivisionError, ImportError)):
                    # This raises ImportError on the "from . import module"
                    # line, not sure why.
                    import_util.import_('pkg')
                self.assertFalse('pkg' in sys.modules)
                with self.assertRaises((ZeroDivisionError, ImportError)):
                    import_util.import_('pkg.module')
                self.assertFalse('pkg' in sys.modules)
                # XXX False
                #self.assertTrue('pkg.module' in sys.modules)

    def test_raising_parent_after_double_relative_importing_child(self):
        def __init__():
            from ..subpkg import module
            1/0
        mock = util.mock_modules('pkg.__init__', 'pkg.subpkg.__init__',
                                 'pkg.subpkg.module',
                                 module_code={'pkg.subpkg': __init__})
        with mock:
            with util.import_state(meta_path=[mock]):
                with self.assertRaises((ZeroDivisionError, ImportError)):
                    # This raises ImportError on the "from ..subpkg import module"
                    # line, not sure why.
                    import_util.import_('pkg.subpkg')
                self.assertFalse('pkg.subpkg' in sys.modules)
                with self.assertRaises((ZeroDivisionError, ImportError)):
                    import_util.import_('pkg.subpkg.module')
                self.assertFalse('pkg.subpkg' in sys.modules)
                # XXX False
                #self.assertTrue('pkg.subpkg.module' in sys.modules)

    def test_module_not_package(self):
        # Try to import a submodule from a non-package should raise ImportError.
        assert not hasattr(sys, '__path__')
        with self.assertRaises(ImportError) as cm:
            import_util.import_('sys.no_submodules_here')
        self.assertEqual(cm.exception.name, 'sys.no_submodules_here')

    def test_module_not_package_but_side_effects(self):
        # If a module injects something into sys.modules as a side-effect, then
        # pick up on that fact.
        name = 'mod'
        subname = name + '.b'
        def module_injection():
            sys.modules[subname] = 'total bunk'
        mock_modules = util.mock_modules('mod',
                                         module_code={'mod': module_injection})
        with mock_modules as mock:
            with util.import_state(meta_path=[mock]):
                try:
                    submodule = import_util.import_(subname)
                finally:
                    support.unload(subname)


def test_main():
    from test.support import run_unittest
    run_unittest(ParentModuleTests)


if __name__ == '__main__':
    test_main()