mirror of
https://github.com/django/django.git
synced 2024-12-28 03:55:50 +00:00
253 lines
9.5 KiB
Python
253 lines
9.5 KiB
Python
import os
|
|
import sys
|
|
import unittest
|
|
from importlib import import_module
|
|
from zipimport import zipimporter
|
|
|
|
from django.test import SimpleTestCase, modify_settings
|
|
from django.test.utils import extend_sys_path
|
|
from django.utils.module_loading import (
|
|
autodiscover_modules,
|
|
import_string,
|
|
module_has_submodule,
|
|
)
|
|
from django.utils.version import PY310
|
|
|
|
|
|
class DefaultLoader(unittest.TestCase):
|
|
def test_loader(self):
|
|
"Normal module existence can be tested"
|
|
test_module = import_module("utils_tests.test_module")
|
|
test_no_submodule = import_module("utils_tests.test_no_submodule")
|
|
|
|
# An importable child
|
|
self.assertTrue(module_has_submodule(test_module, "good_module"))
|
|
mod = import_module("utils_tests.test_module.good_module")
|
|
self.assertEqual(mod.content, "Good Module")
|
|
|
|
# A child that exists, but will generate an import error if loaded
|
|
self.assertTrue(module_has_submodule(test_module, "bad_module"))
|
|
with self.assertRaises(ImportError):
|
|
import_module("utils_tests.test_module.bad_module")
|
|
|
|
# A child that doesn't exist
|
|
self.assertFalse(module_has_submodule(test_module, "no_such_module"))
|
|
with self.assertRaises(ImportError):
|
|
import_module("utils_tests.test_module.no_such_module")
|
|
|
|
# A child that doesn't exist, but is the name of a package on the path
|
|
self.assertFalse(module_has_submodule(test_module, "django"))
|
|
with self.assertRaises(ImportError):
|
|
import_module("utils_tests.test_module.django")
|
|
|
|
# Don't be confused by caching of import misses
|
|
import types # NOQA: causes attempted import of utils_tests.types
|
|
|
|
self.assertFalse(module_has_submodule(sys.modules["utils_tests"], "types"))
|
|
|
|
# A module which doesn't have a __path__ (so no submodules)
|
|
self.assertFalse(module_has_submodule(test_no_submodule, "anything"))
|
|
with self.assertRaises(ImportError):
|
|
import_module("utils_tests.test_no_submodule.anything")
|
|
|
|
def test_has_sumbodule_with_dotted_path(self):
|
|
"""Nested module existence can be tested."""
|
|
test_module = import_module("utils_tests.test_module")
|
|
# A grandchild that exists.
|
|
self.assertIs(
|
|
module_has_submodule(test_module, "child_module.grandchild_module"), True
|
|
)
|
|
# A grandchild that doesn't exist.
|
|
self.assertIs(
|
|
module_has_submodule(test_module, "child_module.no_such_module"), False
|
|
)
|
|
# A grandchild whose parent doesn't exist.
|
|
self.assertIs(
|
|
module_has_submodule(test_module, "no_such_module.grandchild_module"), False
|
|
)
|
|
# A grandchild whose parent is not a package.
|
|
self.assertIs(
|
|
module_has_submodule(test_module, "good_module.no_such_module"), False
|
|
)
|
|
|
|
|
|
class EggLoader(unittest.TestCase):
|
|
def setUp(self):
|
|
self.egg_dir = "%s/eggs" % os.path.dirname(__file__)
|
|
|
|
def tearDown(self):
|
|
sys.path_importer_cache.clear()
|
|
|
|
sys.modules.pop("egg_module.sub1.sub2.bad_module", None)
|
|
sys.modules.pop("egg_module.sub1.sub2.good_module", None)
|
|
sys.modules.pop("egg_module.sub1.sub2", None)
|
|
sys.modules.pop("egg_module.sub1", None)
|
|
sys.modules.pop("egg_module.bad_module", None)
|
|
sys.modules.pop("egg_module.good_module", None)
|
|
sys.modules.pop("egg_module", None)
|
|
|
|
def test_shallow_loader(self):
|
|
"Module existence can be tested inside eggs"
|
|
egg_name = "%s/test_egg.egg" % self.egg_dir
|
|
with extend_sys_path(egg_name):
|
|
egg_module = import_module("egg_module")
|
|
|
|
# An importable child
|
|
self.assertTrue(module_has_submodule(egg_module, "good_module"))
|
|
mod = import_module("egg_module.good_module")
|
|
self.assertEqual(mod.content, "Good Module")
|
|
|
|
# A child that exists, but will generate an import error if loaded
|
|
self.assertTrue(module_has_submodule(egg_module, "bad_module"))
|
|
with self.assertRaises(ImportError):
|
|
import_module("egg_module.bad_module")
|
|
|
|
# A child that doesn't exist
|
|
self.assertFalse(module_has_submodule(egg_module, "no_such_module"))
|
|
with self.assertRaises(ImportError):
|
|
import_module("egg_module.no_such_module")
|
|
|
|
def test_deep_loader(self):
|
|
"Modules deep inside an egg can still be tested for existence"
|
|
egg_name = "%s/test_egg.egg" % self.egg_dir
|
|
with extend_sys_path(egg_name):
|
|
egg_module = import_module("egg_module.sub1.sub2")
|
|
|
|
# An importable child
|
|
self.assertTrue(module_has_submodule(egg_module, "good_module"))
|
|
mod = import_module("egg_module.sub1.sub2.good_module")
|
|
self.assertEqual(mod.content, "Deep Good Module")
|
|
|
|
# A child that exists, but will generate an import error if loaded
|
|
self.assertTrue(module_has_submodule(egg_module, "bad_module"))
|
|
with self.assertRaises(ImportError):
|
|
import_module("egg_module.sub1.sub2.bad_module")
|
|
|
|
# A child that doesn't exist
|
|
self.assertFalse(module_has_submodule(egg_module, "no_such_module"))
|
|
with self.assertRaises(ImportError):
|
|
import_module("egg_module.sub1.sub2.no_such_module")
|
|
|
|
|
|
class ModuleImportTests(SimpleTestCase):
|
|
def test_import_string(self):
|
|
cls = import_string("django.utils.module_loading.import_string")
|
|
self.assertEqual(cls, import_string)
|
|
|
|
# Test exceptions raised
|
|
with self.assertRaises(ImportError):
|
|
import_string("no_dots_in_path")
|
|
msg = 'Module "utils_tests" does not define a "unexistent" attribute'
|
|
with self.assertRaisesMessage(ImportError, msg):
|
|
import_string("utils_tests.unexistent")
|
|
|
|
|
|
@modify_settings(INSTALLED_APPS={"append": "utils_tests.test_module"})
|
|
class AutodiscoverModulesTestCase(SimpleTestCase):
|
|
def tearDown(self):
|
|
sys.path_importer_cache.clear()
|
|
|
|
sys.modules.pop("utils_tests.test_module.another_bad_module", None)
|
|
sys.modules.pop("utils_tests.test_module.another_good_module", None)
|
|
sys.modules.pop("utils_tests.test_module.bad_module", None)
|
|
sys.modules.pop("utils_tests.test_module.good_module", None)
|
|
sys.modules.pop("utils_tests.test_module", None)
|
|
|
|
def test_autodiscover_modules_found(self):
|
|
autodiscover_modules("good_module")
|
|
|
|
def test_autodiscover_modules_not_found(self):
|
|
autodiscover_modules("missing_module")
|
|
|
|
def test_autodiscover_modules_found_but_bad_module(self):
|
|
with self.assertRaisesMessage(
|
|
ImportError, "No module named 'a_package_name_that_does_not_exist'"
|
|
):
|
|
autodiscover_modules("bad_module")
|
|
|
|
def test_autodiscover_modules_several_one_bad_module(self):
|
|
with self.assertRaisesMessage(
|
|
ImportError, "No module named 'a_package_name_that_does_not_exist'"
|
|
):
|
|
autodiscover_modules("good_module", "bad_module")
|
|
|
|
def test_autodiscover_modules_several_found(self):
|
|
autodiscover_modules("good_module", "another_good_module")
|
|
|
|
def test_autodiscover_modules_several_found_with_registry(self):
|
|
from .test_module import site
|
|
|
|
autodiscover_modules("good_module", "another_good_module", register_to=site)
|
|
self.assertEqual(site._registry, {"lorem": "ipsum"})
|
|
|
|
def test_validate_registry_keeps_intact(self):
|
|
from .test_module import site
|
|
|
|
with self.assertRaisesMessage(Exception, "Some random exception."):
|
|
autodiscover_modules("another_bad_module", register_to=site)
|
|
self.assertEqual(site._registry, {})
|
|
|
|
def test_validate_registry_resets_after_erroneous_module(self):
|
|
from .test_module import site
|
|
|
|
with self.assertRaisesMessage(Exception, "Some random exception."):
|
|
autodiscover_modules(
|
|
"another_good_module", "another_bad_module", register_to=site
|
|
)
|
|
self.assertEqual(site._registry, {"lorem": "ipsum"})
|
|
|
|
def test_validate_registry_resets_after_missing_module(self):
|
|
from .test_module import site
|
|
|
|
autodiscover_modules(
|
|
"does_not_exist", "another_good_module", "does_not_exist2", register_to=site
|
|
)
|
|
self.assertEqual(site._registry, {"lorem": "ipsum"})
|
|
|
|
|
|
if PY310:
|
|
|
|
class TestFinder:
|
|
def __init__(self, *args, **kwargs):
|
|
self.importer = zipimporter(*args, **kwargs)
|
|
|
|
def find_spec(self, path, target=None):
|
|
return self.importer.find_spec(path, target)
|
|
|
|
else:
|
|
|
|
class TestFinder:
|
|
def __init__(self, *args, **kwargs):
|
|
self.importer = zipimporter(*args, **kwargs)
|
|
|
|
def find_module(self, path):
|
|
importer = self.importer.find_module(path)
|
|
if importer is None:
|
|
return
|
|
return TestLoader(importer)
|
|
|
|
class TestLoader:
|
|
def __init__(self, importer):
|
|
self.importer = importer
|
|
|
|
def load_module(self, name):
|
|
mod = self.importer.load_module(name)
|
|
mod.__loader__ = self
|
|
return mod
|
|
|
|
|
|
class CustomLoader(EggLoader):
|
|
"""The Custom Loader test is exactly the same as the EggLoader, but
|
|
it uses a custom defined Loader class. Although the EggLoader combines both
|
|
functions into one class, this isn't required.
|
|
"""
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
sys.path_hooks.insert(0, TestFinder)
|
|
sys.path_importer_cache.clear()
|
|
|
|
def tearDown(self):
|
|
super().tearDown()
|
|
sys.path_hooks.pop(0)
|