path: root/Lib/test/test_importlib/test_abc.py

import importlib
import importlib.util
from importlib import abc
from importlib import machinery

import contextlib
import inspect
import io
import marshal
import os
import sys
from test import support
import types
import unittest
from unittest import mock

from . import util

##### Inheritance ##############################################################
class InheritanceTests:

    """Test that the specified class is a subclass/superclass of the expected
    classes."""

    subclasses = []
    superclasses = []

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        assert self.subclasses or self.superclasses, self.__class__
        self.__test = getattr(abc, self.__class__.__name__)

    def test_subclasses(self):
        # Test that the expected subclasses inherit.
        for subclass in self.subclasses:
            self.assertTrue(issubclass(subclass, self.__test),
                "{0} is not a subclass of {1}".format(subclass, self.__test))

    def test_superclasses(self):
        # Test that the class inherits from the expected superclasses.
        for superclass in self.superclasses:
            self.assertTrue(issubclass(self.__test, superclass),
               "{0} is not a superclass of {1}".format(superclass, self.__test))


class MetaPathFinder(InheritanceTests, unittest.TestCase):

    superclasses = [abc.Finder]
    subclasses = [machinery.BuiltinImporter, machinery.FrozenImporter,
                    machinery.PathFinder, machinery.WindowsRegistryFinder]


class PathEntryFinder(InheritanceTests, unittest.TestCase):

    superclasses = [abc.Finder]
    subclasses = [machinery.FileFinder]


class ResourceLoader(InheritanceTests, unittest.TestCase):

    superclasses = [abc.Loader]


class InspectLoader(InheritanceTests, unittest.TestCase):

    superclasses = [abc.Loader]
    subclasses = [machinery.BuiltinImporter,
                    machinery.FrozenImporter, machinery.ExtensionFileLoader]


class ExecutionLoader(InheritanceTests, unittest.TestCase):

    superclasses = [abc.InspectLoader]


class FileLoader(InheritanceTests, unittest.TestCase):

    superclasses = [abc.ResourceLoader, abc.ExecutionLoader]
    subclasses = [machinery.SourceFileLoader, machinery.SourcelessFileLoader]


class SourceLoader(InheritanceTests, unittest.TestCase):

    superclasses = [abc.ResourceLoader, abc.ExecutionLoader]
    subclasses = [machinery.SourceFileLoader]


##### Default return values ####################################################
class MetaPathFinderSubclass(abc.MetaPathFinder):

    def find_module(self, fullname, path):
        return super().find_module(fullname, path)


class MetaPathFinderDefaultsTests(unittest.TestCase):

    ins = MetaPathFinderSubclass()

    def test_find_module(self):
        # Default should return None.
        self.assertIsNone(self.ins.find_module('something', None))

    def test_invalidate_caches(self):
        # Calling the method is a no-op.
        self.ins.invalidate_caches()


class PathEntryFinderSubclass(abc.PathEntryFinder):

    def find_loader(self, fullname):
        return super().find_loader(fullname)


class PathEntryFinderDefaultsTests(unittest.TestCase):

    ins = PathEntryFinderSubclass()

    def test_find_loader(self):
        self.assertEqual((None, []), self.ins.find_loader('something'))

    def find_module(self):
        self.assertEqual(None, self.ins.find_module('something'))

    def test_invalidate_caches(self):
        # Should be a no-op.
        self.ins.invalidate_caches()


class LoaderSubclass(abc.Loader):

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


class LoaderDefaultsTests(unittest.TestCase):

    ins = LoaderSubclass()

    def test_load_module(self):
        with self.assertRaises(ImportError):
            self.ins.load_module('something')

    def test_module_repr(self):
        mod = types.ModuleType('blah')
        with self.assertRaises(NotImplementedError):
            self.ins.module_repr(mod)
        original_repr = repr(mod)
        mod.__loader__ = self.ins
        # Should still return a proper repr.
        self.assertTrue(repr(mod))


class ResourceLoaderSubclass(LoaderSubclass, abc.ResourceLoader):

    def get_data(self, path):
        return super().get_data(path)


class ResourceLoaderDefaultsTests(unittest.TestCase):

    ins = ResourceLoaderSubclass()

    def test_get_data(self):
        with self.assertRaises(IOError):
            self.ins.get_data('/some/path')


class InspectLoaderSubclass(LoaderSubclass, abc.InspectLoader):

    def is_package(self, fullname):
        return super().is_package(fullname)

    def get_source(self, fullname):
        return super().get_source(fullname)


class InspectLoaderDefaultsTests(unittest.TestCase):

    ins = InspectLoaderSubclass()

    def test_is_package(self):
        with self.assertRaises(ImportError):
            self.ins.is_package('blah')

    def test_get_source(self):
        with self.assertRaises(ImportError):
            self.ins.get_source('blah')


class ExecutionLoaderSubclass(InspectLoaderSubclass, abc.ExecutionLoader):

    def get_filename(self, fullname):
        return super().get_filename(fullname)


class ExecutionLoaderDefaultsTests(unittest.TestCase):

    ins = ExecutionLoaderSubclass()

    def test_get_filename(self):
        with self.assertRaises(ImportError):
            self.ins.get_filename('blah')

##### Loader concrete methods ##################################################
class LoaderConcreteMethodTests(unittest.TestCase):

    def test_init_module_attrs(self):
        loader = LoaderSubclass()
        module = types.ModuleType('blah')
        loader.init_module_attrs(module)
        self.assertEqual(module.__loader__, loader)


##### InspectLoader concrete methods ###########################################
class InspectLoaderSourceToCodeTests(unittest.TestCase):

    def source_to_module(self, data, path=None):
        """Help with source_to_code() tests."""
        module = types.ModuleType('blah')
        loader = InspectLoaderSubclass()
        if path is None:
            code = loader.source_to_code(data)
        else:
            code = loader.source_to_code(data, path)
        exec(code, module.__dict__)
        return module

    def test_source_to_code_source(self):
        # Since compile() can handle strings, so should source_to_code().
        source = 'attr = 42'
        module = self.source_to_module(source)
        self.assertTrue(hasattr(module, 'attr'))
        self.assertEqual(module.attr, 42)

    def test_source_to_code_bytes(self):
        # Since compile() can handle bytes, so should source_to_code().
        source = b'attr = 42'
        module = self.source_to_module(source)
        self.assertTrue(hasattr(module, 'attr'))
        self.assertEqual(module.attr, 42)

    def test_source_to_code_path(self):
        # Specifying a path should set it for the code object.
        path = 'path/to/somewhere'
        loader = InspectLoaderSubclass()
        code = loader.source_to_code('', path)
        self.assertEqual(code.co_filename, path)

    def test_source_to_code_no_path(self):
        # Not setting a path should still work and be set to <string> since that
        # is a pre-existing practice as a default to compile().
        loader = InspectLoaderSubclass()
        code = loader.source_to_code('')
        self.assertEqual(code.co_filename, '<string>')


class InspectLoaderGetCodeTests(unittest.TestCase):

    def test_get_code(self):
        # Test success.
        module = types.ModuleType('blah')
        with mock.patch.object(InspectLoaderSubclass, 'get_source') as mocked:
            mocked.return_value = 'attr = 42'
            loader = InspectLoaderSubclass()
            code = loader.get_code('blah')
        exec(code, module.__dict__)
        self.assertEqual(module.attr, 42)

    def test_get_code_source_is_None(self):
        # If get_source() is None then this should be None.
        with mock.patch.object(InspectLoaderSubclass, 'get_source') as mocked:
            mocked.return_value = None
            loader = InspectLoaderSubclass()
            code = loader.get_code('blah')
        self.assertIsNone(code)

    def test_get_code_source_not_found(self):
        # If there is no source then there is no code object.
        loader = InspectLoaderSubclass()
        with self.assertRaises(ImportError):
            loader.get_code('blah')


class InspectLoaderInitModuleTests(unittest.TestCase):

    @staticmethod
    def mock_is_package(return_value):
        return mock.patch.object(InspectLoaderSubclass, 'is_package',
                                 return_value=return_value)

    def init_module_attrs(self, name):
        loader = InspectLoaderSubclass()
        module = types.ModuleType(name)
        loader.init_module_attrs(module)
        self.assertEqual(module.__loader__, loader)
        return module

    def test_package(self):
        # If a package, then __package__ == __name__, __path__ == []
        with self.mock_is_package(True):
            name = 'blah'
            module = self.init_module_attrs(name)
            self.assertEqual(module.__package__, name)
            self.assertEqual(module.__path__, [])

    def test_toplevel(self):
        # If a module is top-level, __package__ == ''
        with self.mock_is_package(False):
            name = 'blah'
            module = self.init_module_attrs(name)
            self.assertEqual(module.__package__, '')

    def test_submodule(self):
        # If a module is contained within a package then set __package__ to the
        # package name.
        with self.mock_is_package(False):
            name = 'pkg.mod'
            module = self.init_module_attrs(name)
            self.assertEqual(module.__package__, 'pkg')

    def test_is_package_ImportError(self):
        # If is_package() raises ImportError, __package__ should be None and
        # __path__ should not be set.
        with self.mock_is_package(False) as mocked_method:
            mocked_method.side_effect = ImportError
            name = 'mod'
            module = self.init_module_attrs(name)
            self.assertIsNone(module.__package__)
            self.assertFalse(hasattr(module, '__path__'))


class InspectLoaderLoadModuleTests(unittest.TestCase):

    """Test InspectLoader.load_module()."""

    module_name = 'blah'

    def setUp(self):
        support.unload(self.module_name)
        self.addCleanup(support.unload, self.module_name)

    def mock_get_code(self):
        return mock.patch.object(InspectLoaderSubclass, 'get_code')

    def test_get_code_ImportError(self):
        # If get_code() raises ImportError, it should propagate.
        with self.mock_get_code() as mocked_get_code:
            mocked_get_code.side_effect = ImportError
            with self.assertRaises(ImportError):
                loader = InspectLoaderSubclass()
                loader.load_module(self.module_name)

    def test_get_code_None(self):
        # If get_code() returns None, raise ImportError.
        with self.mock_get_code() as mocked_get_code:
            mocked_get_code.return_value = None
            with self.assertRaises(ImportError):
                loader = InspectLoaderSubclass()
                loader.load_module(self.module_name)

    def test_module_returned(self):
        # The loaded module should be returned.
        code = compile('attr = 42', '<string>', 'exec')
        with self.mock_get_code() as mocked_get_code:
            mocked_get_code.return_value = code
            loader = InspectLoaderSubclass()
            module = loader.load_module(self.module_name)
            self.assertEqual(module, sys.modules[self.module_name])


##### ExecutionLoader concrete methods #########################################
class ExecutionLoaderGetCodeTests(unittest.TestCase):

    def mock_methods(self, *, get_source=False, get_filename=False):
        source_mock_context, filename_mock_context = None, None
        if get_source:
            source_mock_context = mock.patch.object(ExecutionLoaderSubclass,
                                                    'get_source')
        if get_filename:
            filename_mock_context = mock.patch.object(ExecutionLoaderSubclass,
                                                      'get_filename')
        return source_mock_context, filename_mock_context

    def test_get_code(self):
        path = 'blah.py'
        source_mock_context, filename_mock_context = self.mock_methods(
                get_source=True, get_filename=True)
        with source_mock_context as source_mock, filename_mock_context as name_mock:
            source_mock.return_value = 'attr = 42'
            name_mock.return_value = path
            loader = ExecutionLoaderSubclass()
            code = loader.get_code('blah')
        self.assertEqual(code.co_filename, path)
        module = types.ModuleType('blah')
        exec(code, module.__dict__)
        self.assertEqual(module.attr, 42)

    def test_get_code_source_is_None(self):
        # If get_source() is None then this should be None.
        source_mock_context, _ = self.mock_methods(get_source=True)
        with source_mock_context as mocked:
            mocked.return_value = None
            loader = ExecutionLoaderSubclass()
            code = loader.get_code('blah')
        self.assertIsNone(code)

    def test_get_code_source_not_found(self):
        # If there is no source then there is no code object.
        loader = ExecutionLoaderSubclass()
        with self.assertRaises(ImportError):
            loader.get_code('blah')

    def test_get_code_no_path(self):
        # If get_filename() raises ImportError then simply skip setting the path
        # on the code object.
        source_mock_context, filename_mock_context = self.mock_methods(
                get_source=True, get_filename=True)
        with source_mock_context as source_mock, filename_mock_context as name_mock:
            source_mock.return_value = 'attr = 42'
            name_mock.side_effect = ImportError
            loader = ExecutionLoaderSubclass()
            code = loader.get_code('blah')
        self.assertEqual(code.co_filename, '<string>')
        module = types.ModuleType('blah')
        exec(code, module.__dict__)
        self.assertEqual(module.attr, 42)


class ExecutionLoaderInitModuleTests(unittest.TestCase):

    @staticmethod
    @contextlib.contextmanager
    def mock_methods(is_package, filename):
        is_package_manager = InspectLoaderInitModuleTests.mock_is_package(is_package)
        get_filename_manager = mock.patch.object(ExecutionLoaderSubclass,
                'get_filename', return_value=filename)
        with is_package_manager as mock_is_package:
            with get_filename_manager as mock_get_filename:
                yield {'is_package': mock_is_package,
                       'get_filename': mock_get_filename}

    def test_toplevel(self):
        # Verify __loader__, __file__, and __package__; no __path__.
        name = 'blah'
        path = os.path.join('some', 'path', '{}.py'.format(name))
        with self.mock_methods(False, path):
            loader = ExecutionLoaderSubclass()
            module = types.ModuleType(name)
            loader.init_module_attrs(module)
        self.assertIs(module.__loader__, loader)
        self.assertEqual(module.__file__, path)
        self.assertEqual(module.__package__, '')
        self.assertFalse(hasattr(module, '__path__'))

    def test_package(self):
        # Verify __loader__, __file__, __package__, and __path__.
        name = 'pkg'
        path = os.path.join('some', 'pkg', '__init__.py')
        with self.mock_methods(True, path):
            loader = ExecutionLoaderSubclass()
            module = types.ModuleType(name)
            loader.init_module_attrs(module)
        self.assertIs(module.__loader__, loader)
        self.assertEqual(module.__file__, path)
        self.assertEqual(module.__package__, 'pkg')
        self.assertEqual(module.__path__, [os.path.dirname(path)])

    def test_submodule(self):
        # Verify __package__ and not __path__; test_toplevel() takes care of
        # other attributes.
        name = 'pkg.submodule'
        path = os.path.join('some', 'pkg', 'submodule.py')
        with self.mock_methods(False, path):
            loader = ExecutionLoaderSubclass()
            module = types.ModuleType(name)
            loader.init_module_attrs(module)
        self.assertEqual(module.__package__, 'pkg')
        self.assertEqual(module.__file__, path)
        self.assertFalse(hasattr(module, '__path__'))

    def test_get_filename_ImportError(self):
        # If get_filename() raises ImportError, don't set __file__.
        name = 'blah'
        path = 'blah.py'
        with self.mock_methods(False, path) as mocked_methods:
            mocked_methods['get_filename'].side_effect = ImportError
            loader = ExecutionLoaderSubclass()
            module = types.ModuleType(name)
            loader.init_module_attrs(module)
        self.assertFalse(hasattr(module, '__file__'))


##### SourceLoader concrete methods ############################################
class SourceOnlyLoaderMock(abc.SourceLoader):

    # Globals that should be defined for all modules.
    source = (b"_ = '::'.join([__name__, __file__, __cached__, __package__, "
              b"repr(__loader__)])")

    def __init__(self, path):
        self.path = path

    def get_data(self, path):
        if path != self.path:
            raise IOError
        return self.source

    def get_filename(self, fullname):
        return self.path

    def module_repr(self, module):
        return '<module>'


class SourceLoaderMock(SourceOnlyLoaderMock):

    source_mtime = 1

    def __init__(self, path, magic=importlib.util.MAGIC_NUMBER):
        super().__init__(path)
        self.bytecode_path = importlib.util.cache_from_source(self.path)
        self.source_size = len(self.source)
        data = bytearray(magic)
        data.extend(importlib._w_long(self.source_mtime))
        data.extend(importlib._w_long(self.source_size))
        code_object = compile(self.source, self.path, 'exec',
                                dont_inherit=True)
        data.extend(marshal.dumps(code_object))
        self.bytecode = bytes(data)
        self.written = {}

    def get_data(self, path):
        if path == self.path:
            return super().get_data(path)
        elif path == self.bytecode_path:
            return self.bytecode
        else:
            raise OSError

    def path_stats(self, path):
        if path != self.path:
            raise IOError
        return {'mtime': self.source_mtime, 'size': self.source_size}

    def set_data(self, path, data):
        self.written[path] = bytes(data)
        return path == self.bytecode_path


class SourceLoaderTestHarness(unittest.TestCase):

    def setUp(self, *, is_package=True, **kwargs):
        self.package = 'pkg'
        if is_package:
            self.path = os.path.join(self.package, '__init__.py')
            self.name = self.package
        else:
            module_name = 'mod'
            self.path = os.path.join(self.package, '.'.join(['mod', 'py']))
            self.name = '.'.join([self.package, module_name])
        self.cached = importlib.util.cache_from_source(self.path)
        self.loader = self.loader_mock(self.path, **kwargs)

    def verify_module(self, module):
        self.assertEqual(module.__name__, self.name)
        self.assertEqual(module.__file__, self.path)
        self.assertEqual(module.__cached__, self.cached)
        self.assertEqual(module.__package__, self.package)
        self.assertEqual(module.__loader__, self.loader)
        values = module._.split('::')
        self.assertEqual(values[0], self.name)
        self.assertEqual(values[1], self.path)
        self.assertEqual(values[2], self.cached)
        self.assertEqual(values[3], self.package)
        self.assertEqual(values[4], repr(self.loader))

    def verify_code(self, code_object):
        module = types.ModuleType(self.name)
        module.__file__ = self.path
        module.__cached__ = self.cached
        module.__package__ = self.package
        module.__loader__ = self.loader
        module.__path__ = []
        exec(code_object, module.__dict__)
        self.verify_module(module)


class SourceOnlyLoaderTests(SourceLoaderTestHarness):

    """Test importlib.abc.SourceLoader for source-only loading.

    Reload testing is subsumed by the tests for
    importlib.util.module_for_loader.

    """

    loader_mock = SourceOnlyLoaderMock

    def test_get_source(self):
        # Verify the source code is returned as a string.
        # If an OSError is raised by get_data then raise ImportError.
        expected_source = self.loader.source.decode('utf-8')
        self.assertEqual(self.loader.get_source(self.name), expected_source)
        def raise_OSError(path):
            raise OSError
        self.loader.get_data = raise_OSError
        with self.assertRaises(ImportError) as cm:
            self.loader.get_source(self.name)
        self.assertEqual(cm.exception.name, self.name)

    def test_is_package(self):
        # Properly detect when loading a package.
        self.setUp(is_package=False)
        self.assertFalse(self.loader.is_package(self.name))
        self.setUp(is_package=True)
        self.assertTrue(self.loader.is_package(self.name))
        self.assertFalse(self.loader.is_package(self.name + '.__init__'))

    def test_get_code(self):
        # Verify the code object is created.
        code_object = self.loader.get_code(self.name)
        self.verify_code(code_object)

    def test_source_to_code(self):
        # Verify the compiled code object.
        code = self.loader.source_to_code(self.loader.source, self.path)
        self.verify_code(code)

    def test_load_module(self):
        # Loading a module should set __name__, __loader__, __package__,
        # __path__ (for packages), __file__, and __cached__.
        # The module should also be put into sys.modules.
        with util.uncache(self.name):
            module = self.loader.load_module(self.name)
            self.verify_module(module)
            self.assertEqual(module.__path__, [os.path.dirname(self.path)])
            self.assertIn(self.name, sys.modules)

    def test_package_settings(self):
        # __package__ needs to be set, while __path__ is set on if the module
        # is a package.
        # Testing the values for a package are covered by test_load_module.
        self.setUp(is_package=False)
        with util.uncache(self.name):
            module = self.loader.load_module(self.name)
            self.verify_module(module)
            self.assertTrue(not hasattr(module, '__path__'))

    def test_get_source_encoding(self):
        # Source is considered encoded in UTF-8 by default unless otherwise
        # specified by an encoding line.
        source = "_ = 'ü'"
        self.loader.source = source.encode('utf-8')
        returned_source = self.loader.get_source(self.name)
        self.assertEqual(returned_source, source)
        source = "# coding: latin-1\n_ = ü"
        self.loader.source = source.encode('latin-1')
        returned_source = self.loader.get_source(self.name)
        self.assertEqual(returned_source, source)


@unittest.skipIf(sys.dont_write_bytecode, "sys.dont_write_bytecode is true")
class SourceLoaderBytecodeTests(SourceLoaderTestHarness):

    """Test importlib.abc.SourceLoader's use of bytecode.

    Source-only testing handled by SourceOnlyLoaderTests.

    """

    loader_mock = SourceLoaderMock

    def verify_code(self, code_object, *, bytecode_written=False):
        super().verify_code(code_object)
        if bytecode_written:
            self.assertIn(self.cached, self.loader.written)
            data = bytearray(importlib.util.MAGIC_NUMBER)
            data.extend(importlib._w_long(self.loader.source_mtime))
            data.extend(importlib._w_long(self.loader.source_size))
            data.extend(marshal.dumps(code_object))
            self.assertEqual(self.loader.written[self.cached], bytes(data))

    def test_code_with_everything(self):
        # When everything should work.
        code_object = self.loader.get_code(self.name)
        self.verify_code(code_object)

    def test_no_bytecode(self):
        # If no bytecode exists then move on to the source.
        self.loader.bytecode_path = "<does not exist>"
        # Sanity check
        with self.assertRaises(OSError):
            bytecode_path = importlib.util.cache_from_source(self.path)
            self.loader.get_data(bytecode_path)
        code_object = self.loader.get_code(self.name)
        self.verify_code(code_object, bytecode_written=True)

    def test_code_bad_timestamp(self):
        # Bytecode is only used when the timestamp matches the source EXACTLY.
        for source_mtime in (0, 2):
            assert source_mtime != self.loader.source_mtime
            original = self.loader.source_mtime
            self.loader.source_mtime = source_mtime
            # If bytecode is used then EOFError would be raised by marshal.
            self.loader.bytecode = self.loader.bytecode[8:]
            code_object = self.loader.get_code(self.name)
            self.verify_code(code_object, bytecode_written=True)
            self.loader.source_mtime = original

    def test_code_bad_magic(self):
        # Skip over bytecode with a bad magic number.
        self.setUp(magic=b'0000')
        # If bytecode is used then EOFError would be raised by marshal.
        self.loader.bytecode = self.loader.bytecode[8:]
        code_object = self.loader.get_code(self.name)
        self.verify_code(code_object, bytecode_written=True)

    def test_dont_write_bytecode(self):
        # Bytecode is not written if sys.dont_write_bytecode is true.
        # Can assume it is false already thanks to the skipIf class decorator.
        try:
            sys.dont_write_bytecode = True
            self.loader.bytecode_path = "<does not exist>"
            code_object = self.loader.get_code(self.name)
            self.assertNotIn(self.cached, self.loader.written)
        finally:
            sys.dont_write_bytecode = False

    def test_no_set_data(self):
        # If set_data is not defined, one can still read bytecode.
        self.setUp(magic=b'0000')
        original_set_data = self.loader.__class__.set_data
        try:
            del self.loader.__class__.set_data
            code_object = self.loader.get_code(self.name)
            self.verify_code(code_object)
        finally:
            self.loader.__class__.set_data = original_set_data

    def test_set_data_raises_exceptions(self):
        # Raising NotImplementedError or OSError is okay for set_data.
        def raise_exception(exc):
            def closure(*args, **kwargs):
                raise exc
            return closure

        self.setUp(magic=b'0000')
        self.loader.set_data = raise_exception(NotImplementedError)
        code_object = self.loader.get_code(self.name)
        self.verify_code(code_object)


class SourceLoaderGetSourceTests(unittest.TestCase):

    """Tests for importlib.abc.SourceLoader.get_source()."""

    def test_default_encoding(self):
        # Should have no problems with UTF-8 text.
        name = 'mod'
        mock = SourceOnlyLoaderMock('mod.file')
        source = 'x = "ü"'
        mock.source = source.encode('utf-8')
        returned_source = mock.get_source(name)
        self.assertEqual(returned_source, source)

    def test_decoded_source(self):
        # Decoding should work.
        name = 'mod'
        mock = SourceOnlyLoaderMock("mod.file")
        source = "# coding: Latin-1\nx='ü'"
        assert source.encode('latin-1') != source.encode('utf-8')
        mock.source = source.encode('latin-1')
        returned_source = mock.get_source(name)
        self.assertEqual(returned_source, source)

    def test_universal_newlines(self):
        # PEP 302 says universal newlines should be used.
        name = 'mod'
        mock = SourceOnlyLoaderMock('mod.file')
        source = "x = 42\r\ny = -13\r\n"
        mock.source = source.encode('utf-8')
        expect = io.IncrementalNewlineDecoder(None, True).decode(source)
        self.assertEqual(mock.get_source(name), expect)


class SourceLoaderInitModuleAttrTests(unittest.TestCase):

    """Tests for importlib.abc.SourceLoader.init_module_attrs()."""

    def test_init_module_attrs(self):
        # If __file__ set, __cached__ == importlib.util.cached_from_source(__file__).
        name = 'blah'
        path = 'blah.py'
        loader = SourceOnlyLoaderMock(path)
        module = types.ModuleType(name)
        loader.init_module_attrs(module)
        self.assertEqual(module.__loader__, loader)
        self.assertEqual(module.__package__, '')
        self.assertEqual(module.__file__, path)
        self.assertEqual(module.__cached__, importlib.util.cache_from_source(path))

    @mock.patch('importlib._bootstrap.cache_from_source')
    def test_cache_from_source_NotImplementedError(self, mock_cache_from_source):
        # If importlib.util.cache_from_source() raises NotImplementedError don't set
        # __cached__.
        mock_cache_from_source.side_effect = NotImplementedError
        name = 'blah'
        path = 'blah.py'
        loader = SourceOnlyLoaderMock(path)
        module = types.ModuleType(name)
        loader.init_module_attrs(module)
        self.assertEqual(module.__file__, path)
        self.assertFalse(hasattr(module, '__cached__'))

    def test_no_get_filename(self):
        # No __file__, no __cached__.
        with mock.patch.object(SourceOnlyLoaderMock, 'get_filename') as mocked:
            mocked.side_effect = ImportError
            name = 'blah'
            loader = SourceOnlyLoaderMock('blah.py')
            module = types.ModuleType(name)
            loader.init_module_attrs(module)
        self.assertFalse(hasattr(module, '__file__'))
        self.assertFalse(hasattr(module, '__cached__'))



if __name__ == '__main__':
    unittest.main()