2009-01-29 20:22:35 -04:00
|
|
|
from .. import abc
|
2013-11-08 12:10:41 -04:00
|
|
|
from .. import util
|
|
|
|
|
|
|
|
machinery = util.import_importlib('importlib.machinery')
|
2009-01-17 20:24:28 -04:00
|
|
|
|
2021-10-05 13:01:27 -03:00
|
|
|
import _imp
|
|
|
|
import marshal
|
|
|
|
import os.path
|
2009-01-17 20:24:28 -04:00
|
|
|
import unittest
|
2021-04-06 12:56:57 -03:00
|
|
|
import warnings
|
2009-01-17 20:24:28 -04:00
|
|
|
|
2021-10-05 13:01:27 -03:00
|
|
|
from test.support import import_helper, REPO_ROOT
|
2021-09-14 20:31:45 -03:00
|
|
|
|
2009-01-17 20:24:28 -04:00
|
|
|
|
2013-11-22 12:05:39 -04:00
|
|
|
class FindSpecTests(abc.FinderTests):
|
|
|
|
|
|
|
|
"""Test finding frozen modules."""
|
|
|
|
|
2021-09-30 21:38:52 -03:00
|
|
|
def find(self, name, **kwargs):
|
2013-11-22 12:05:39 -04:00
|
|
|
finder = self.machinery.FrozenImporter
|
2021-09-14 20:31:45 -03:00
|
|
|
with import_helper.frozen_modules():
|
2021-09-30 21:38:52 -03:00
|
|
|
return finder.find_spec(name, **kwargs)
|
2013-11-22 12:05:39 -04:00
|
|
|
|
2021-10-05 13:01:27 -03:00
|
|
|
def check_basic(self, spec, name, ispkg=False):
|
2021-09-30 21:38:52 -03:00
|
|
|
self.assertEqual(spec.name, name)
|
|
|
|
self.assertIs(spec.loader, self.machinery.FrozenImporter)
|
2013-11-22 12:05:39 -04:00
|
|
|
self.assertEqual(spec.origin, 'frozen')
|
2021-09-30 21:38:52 -03:00
|
|
|
self.assertFalse(spec.has_location)
|
2021-10-05 13:01:27 -03:00
|
|
|
if ispkg:
|
|
|
|
self.assertIsNotNone(spec.submodule_search_locations)
|
|
|
|
else:
|
|
|
|
self.assertIsNone(spec.submodule_search_locations)
|
|
|
|
self.assertIsNotNone(spec.loader_state)
|
|
|
|
|
2021-10-05 13:37:14 -03:00
|
|
|
def check_data(self, spec):
|
2021-10-05 13:01:27 -03:00
|
|
|
with import_helper.frozen_modules():
|
|
|
|
expected = _imp.get_frozen_object(spec.name)
|
|
|
|
data = spec.loader_state
|
|
|
|
# We can't compare the marshaled data directly because
|
|
|
|
# marshal.dumps() would mark "expected" as a ref, which slightly
|
|
|
|
# changes the output. (See https://bugs.python.org/issue34093.)
|
|
|
|
code = marshal.loads(data)
|
|
|
|
self.assertEqual(code, expected)
|
2013-11-22 12:05:39 -04:00
|
|
|
|
2021-10-05 13:37:14 -03:00
|
|
|
def check_search_locations(self, spec):
|
|
|
|
# Frozen packages do not have any path entries.
|
|
|
|
# (See https://bugs.python.org/issue21736.)
|
|
|
|
expected = []
|
|
|
|
self.assertListEqual(spec.submodule_search_locations, expected)
|
|
|
|
|
2021-09-30 21:38:52 -03:00
|
|
|
def test_module(self):
|
2021-10-05 13:37:14 -03:00
|
|
|
modules = [
|
|
|
|
'__hello__',
|
|
|
|
'__phello__.spam',
|
|
|
|
'__phello__.ham.eggs',
|
|
|
|
]
|
|
|
|
for name in modules:
|
|
|
|
with self.subTest(f'{name} -> {name}'):
|
|
|
|
spec = self.find(name)
|
|
|
|
self.check_basic(spec, name)
|
|
|
|
self.check_data(spec)
|
2021-10-05 13:01:27 -03:00
|
|
|
modules = {
|
|
|
|
'__hello_alias__': '__hello__',
|
2021-10-05 13:37:14 -03:00
|
|
|
'_frozen_importlib': 'importlib._bootstrap',
|
|
|
|
}
|
|
|
|
for name, origname in modules.items():
|
|
|
|
with self.subTest(f'{name} -> {origname}'):
|
|
|
|
spec = self.find(name)
|
|
|
|
self.check_basic(spec, name)
|
|
|
|
self.check_data(spec)
|
|
|
|
modules = [
|
|
|
|
'__phello__.__init__',
|
|
|
|
'__phello__.ham.__init__',
|
|
|
|
]
|
|
|
|
for name in modules:
|
|
|
|
origname = name.rpartition('.')[0]
|
|
|
|
with self.subTest(f'{name} -> {origname}'):
|
2021-09-30 21:38:52 -03:00
|
|
|
spec = self.find(name)
|
2021-10-05 13:01:27 -03:00
|
|
|
self.check_basic(spec, name)
|
2021-10-05 13:37:14 -03:00
|
|
|
self.check_data(spec)
|
|
|
|
modules = {
|
|
|
|
'__hello_only__': ('Tools', 'freeze', 'flag.py'),
|
|
|
|
}
|
|
|
|
for name, path in modules.items():
|
|
|
|
filename = os.path.join(REPO_ROOT, *path)
|
|
|
|
with self.subTest(f'{name} -> {filename}'):
|
|
|
|
spec = self.find(name)
|
|
|
|
self.check_basic(spec, name)
|
|
|
|
self.check_data(spec)
|
2013-11-22 12:05:39 -04:00
|
|
|
|
2021-09-30 21:38:52 -03:00
|
|
|
def test_package(self):
|
2021-10-05 13:37:14 -03:00
|
|
|
packages = [
|
|
|
|
'__phello__',
|
|
|
|
'__phello__.ham',
|
|
|
|
]
|
|
|
|
for name in packages:
|
|
|
|
with self.subTest(f'{name} -> {name}'):
|
|
|
|
spec = self.find(name)
|
|
|
|
self.check_basic(spec, name, ispkg=True)
|
|
|
|
self.check_data(spec)
|
|
|
|
self.check_search_locations(spec)
|
|
|
|
packages = {
|
2021-10-05 13:01:27 -03:00
|
|
|
'__phello_alias__': '__hello__',
|
|
|
|
}
|
2021-10-05 13:37:14 -03:00
|
|
|
for name, origname in packages.items():
|
|
|
|
with self.subTest(f'{name} -> {origname}'):
|
2021-09-30 21:38:52 -03:00
|
|
|
spec = self.find(name)
|
2021-10-05 13:01:27 -03:00
|
|
|
self.check_basic(spec, name, ispkg=True)
|
2021-10-05 13:37:14 -03:00
|
|
|
self.check_data(spec)
|
|
|
|
self.check_search_locations(spec)
|
2021-09-30 21:38:52 -03:00
|
|
|
|
|
|
|
# These are covered by test_module() and test_package().
|
|
|
|
test_module_in_package = None
|
2013-11-22 12:05:39 -04:00
|
|
|
test_package_in_package = None
|
|
|
|
|
|
|
|
# No easy way to test.
|
|
|
|
test_package_over_module = None
|
|
|
|
|
2021-09-30 21:38:52 -03:00
|
|
|
def test_path_ignored(self):
|
|
|
|
for name in ('__hello__', '__phello__', '__phello__.spam'):
|
|
|
|
actual = self.find(name)
|
|
|
|
for path in (None, object(), '', 'eggs', [], [''], ['eggs']):
|
|
|
|
with self.subTest((name, path)):
|
|
|
|
spec = self.find(name, path=path)
|
|
|
|
self.assertEqual(spec, actual)
|
|
|
|
|
|
|
|
def test_target_ignored(self):
|
|
|
|
imported = ('__hello__', '__phello__')
|
|
|
|
with import_helper.CleanImport(*imported, usefrozen=True):
|
|
|
|
import __hello__ as match
|
|
|
|
import __phello__ as nonmatch
|
|
|
|
name = '__hello__'
|
|
|
|
actual = self.find(name)
|
|
|
|
for target in (None, match, nonmatch, object(), 'not-a-module-object'):
|
|
|
|
with self.subTest(target):
|
|
|
|
spec = self.find(name, target=target)
|
|
|
|
self.assertEqual(spec, actual)
|
|
|
|
|
2013-11-22 12:05:39 -04:00
|
|
|
def test_failure(self):
|
|
|
|
spec = self.find('<not real>')
|
|
|
|
self.assertIsNone(spec)
|
|
|
|
|
2021-09-30 21:38:52 -03:00
|
|
|
def test_not_using_frozen(self):
|
|
|
|
finder = self.machinery.FrozenImporter
|
|
|
|
with import_helper.frozen_modules(enabled=False):
|
|
|
|
# both frozen and not frozen
|
|
|
|
spec1 = finder.find_spec('__hello__')
|
|
|
|
# only frozen
|
|
|
|
spec2 = finder.find_spec('__hello_only__')
|
|
|
|
self.assertIsNone(spec1)
|
|
|
|
self.assertIsNone(spec2)
|
|
|
|
|
2014-05-16 14:40:40 -03:00
|
|
|
|
|
|
|
(Frozen_FindSpecTests,
|
|
|
|
Source_FindSpecTests
|
|
|
|
) = util.test_both(FindSpecTests, machinery=machinery)
|
2013-11-22 12:05:39 -04:00
|
|
|
|
|
|
|
|
2013-11-08 12:10:41 -04:00
|
|
|
class FinderTests(abc.FinderTests):
|
2009-01-17 20:24:28 -04:00
|
|
|
|
|
|
|
"""Test finding frozen modules."""
|
|
|
|
|
|
|
|
def find(self, name, path=None):
|
2013-11-08 12:10:41 -04:00
|
|
|
finder = self.machinery.FrozenImporter
|
2021-04-06 12:56:57 -03:00
|
|
|
with warnings.catch_warnings():
|
|
|
|
warnings.simplefilter("ignore", DeprecationWarning)
|
2021-09-14 20:31:45 -03:00
|
|
|
with import_helper.frozen_modules():
|
|
|
|
return finder.find_module(name, path)
|
2009-01-17 20:24:28 -04:00
|
|
|
|
|
|
|
def test_module(self):
|
|
|
|
name = '__hello__'
|
|
|
|
loader = self.find(name)
|
2009-06-30 20:06:06 -03:00
|
|
|
self.assertTrue(hasattr(loader, 'load_module'))
|
2009-01-17 20:24:28 -04:00
|
|
|
|
|
|
|
def test_package(self):
|
|
|
|
loader = self.find('__phello__')
|
2009-06-30 20:06:06 -03:00
|
|
|
self.assertTrue(hasattr(loader, 'load_module'))
|
2009-01-17 20:24:28 -04:00
|
|
|
|
|
|
|
def test_module_in_package(self):
|
|
|
|
loader = self.find('__phello__.spam', ['__phello__'])
|
2009-06-30 20:06:06 -03:00
|
|
|
self.assertTrue(hasattr(loader, 'load_module'))
|
2009-01-17 20:24:28 -04:00
|
|
|
|
2013-11-22 12:05:39 -04:00
|
|
|
# No frozen package within another package to test with.
|
|
|
|
test_package_in_package = None
|
2009-01-26 21:44:50 -04:00
|
|
|
|
2013-11-22 12:05:39 -04:00
|
|
|
# No easy way to test.
|
|
|
|
test_package_over_module = None
|
2009-01-17 20:24:28 -04:00
|
|
|
|
|
|
|
def test_failure(self):
|
|
|
|
loader = self.find('<not real>')
|
2012-06-28 07:15:01 -03:00
|
|
|
self.assertIsNone(loader)
|
2009-01-17 20:24:28 -04:00
|
|
|
|
2014-05-16 14:40:40 -03:00
|
|
|
|
|
|
|
(Frozen_FinderTests,
|
|
|
|
Source_FinderTests
|
|
|
|
) = util.test_both(FinderTests, machinery=machinery)
|
2009-01-17 20:24:28 -04:00
|
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
2013-11-08 12:10:41 -04:00
|
|
|
unittest.main()
|