Source

cpython_sandbox / Lib / test / test_importlib / extension / test_loader.py

Full commit
from importlib import machinery
from . import util as ext_util
from .. import abc
from .. import util

import os.path
import sys
import unittest


class LoaderTests(abc.LoaderTests):

    """Test load_module() for extension modules."""

    def setUp(self):
        self.loader = machinery.ExtensionFileLoader(ext_util.NAME,
                                                     ext_util.FILEPATH)

    def load_module(self, fullname):
        return self.loader.load_module(fullname)

    def test_load_module_API(self):
        # Test the default argument for load_module().
        self.loader.load_module()
        self.loader.load_module(None)
        with self.assertRaises(ImportError):
            self.load_module('XXX')


    def test_module(self):
        with util.uncache(ext_util.NAME):
            module = self.load_module(ext_util.NAME)
            for attr, value in [('__name__', ext_util.NAME),
                                ('__file__', ext_util.FILEPATH),
                                ('__package__', '')]:
                self.assertEqual(getattr(module, attr), value)
            self.assertIn(ext_util.NAME, sys.modules)
            self.assertIsInstance(module.__loader__,
                                  machinery.ExtensionFileLoader)

    def test_package(self):
        # No extension module as __init__ available for testing.
        pass

    def test_lacking_parent(self):
        # No extension module in a package available for testing.
        pass

    def test_module_reuse(self):
        with util.uncache(ext_util.NAME):
            module1 = self.load_module(ext_util.NAME)
            module2 = self.load_module(ext_util.NAME)
            self.assertIs(module1, module2)

    def test_state_after_failure(self):
        # No easy way to trigger a failure after a successful import.
        pass

    def test_unloadable(self):
        name = 'asdfjkl;'
        with self.assertRaises(ImportError) as cm:
            self.load_module(name)
        self.assertEqual(cm.exception.name, name)

    def test_is_package(self):
        self.assertFalse(self.loader.is_package(ext_util.NAME))
        for suffix in machinery.EXTENSION_SUFFIXES:
            path = os.path.join('some', 'path', 'pkg', '__init__' + suffix)
            loader = machinery.ExtensionFileLoader('pkg', path)
            self.assertTrue(loader.is_package('pkg'))


class ImportExecTests(unittest.TestCase):
    """Tests for the PyImportExec_* hook"""

    def setUp(self):
        self.mod_info = ext_util._testimportexec_info
        self.loader = machinery.ExtensionFileLoader(self.mod_info.name,
                                                    self.mod_info.filepath)

    def load_module(self, fullname):
        return self.loader.load_module(fullname)

    def test_importexec(self):
        modname = self.mod_info.name
        modpath = self.mod_info.filepath
        with util.uncache(modname):
            module = self.load_module(modname)
            for attr, value in [('__name__', modname),
                                ('__file__', modpath),
                                ('__package__', '')]:
                self.assertEqual(getattr(module, attr), value)
            self.assertIn(modname, sys.modules)
            self.assertIsInstance(module.__loader__,
                                  machinery.ExtensionFileLoader)


def test_main():
    from test.support import run_unittest
    run_unittest(LoaderTests, ImportExecTests)


if __name__ == '__main__':
    test_main()