1 import os

     2 import sys

     3 import unittest

     4 from zipimport import zipimporter

     5 

     6 from django.utils.importlib import import_module

     7 from django.utils.module_loading import module_has_submodule

     8 

     9 class DefaultLoader(unittest.TestCase):

    10     def test_loader(self):

    11         "Normal module existence can be tested"

    12         test_module = import_module('regressiontests.utils.test_module')

    13 

    14         # An importable child

    15         self.assertTrue(module_has_submodule(test_module, 'good_module'))

    16         mod = import_module('regressiontests.utils.test_module.good_module')

    17         self.assertEqual(mod.content, 'Good Module')

    18 

    19         # A child that exists, but will generate an import error if loaded

    20         self.assertTrue(module_has_submodule(test_module, 'bad_module'))

    21         self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.bad_module')

    22 

    23         # A child that doesn't exist

    24         self.assertFalse(module_has_submodule(test_module, 'no_such_module'))

    25         self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.no_such_module')

    26 

    27 class EggLoader(unittest.TestCase):

    28     def setUp(self):

    29         self.old_path = sys.path[:]

    30         self.egg_dir = '%s/eggs' % os.path.dirname(__file__)

    31 

    32     def tearDown(self):

    33         sys.path = self.old_path

    34         sys.path_importer_cache.clear()

    35 

    36         sys.modules.pop('egg_module.sub1.sub2.bad_module', None)

    37         sys.modules.pop('egg_module.sub1.sub2.good_module', None)

    38         sys.modules.pop('egg_module.sub1.sub2', None)

    39         sys.modules.pop('egg_module.sub1', None)

    40         sys.modules.pop('egg_module.bad_module', None)

    41         sys.modules.pop('egg_module.good_module', None)

    42         sys.modules.pop('egg_module', None)

    43 

    44     def test_shallow_loader(self):

    45         "Module existence can be tested inside eggs"

    46         egg_name = '%s/test_egg.egg' % self.egg_dir

    47         sys.path.append(egg_name)

    48         egg_module = import_module('egg_module')

    49 

    50         # An importable child

    51         self.assertTrue(module_has_submodule(egg_module, 'good_module'))

    52         mod = import_module('egg_module.good_module')

    53         self.assertEqual(mod.content, 'Good Module')

    54 

    55         # A child that exists, but will generate an import error if loaded

    56         self.assertTrue(module_has_submodule(egg_module, 'bad_module'))

    57         self.assertRaises(ImportError, import_module, 'egg_module.bad_module')

    58 

    59         # A child that doesn't exist

    60         self.assertFalse(module_has_submodule(egg_module, 'no_such_module'))

    61         self.assertRaises(ImportError, import_module, 'egg_module.no_such_module')

    62 

    63     def test_deep_loader(self):

    64         "Modules deep inside an egg can still be tested for existence"

    65         egg_name = '%s/test_egg.egg' % self.egg_dir

    66         sys.path.append(egg_name)

    67         egg_module = import_module('egg_module.sub1.sub2')

    68 

    69         # An importable child

    70         self.assertTrue(module_has_submodule(egg_module, 'good_module'))

    71         mod = import_module('egg_module.sub1.sub2.good_module')

    72         self.assertEqual(mod.content, 'Deep Good Module')

    73 

    74         # A child that exists, but will generate an import error if loaded

    75         self.assertTrue(module_has_submodule(egg_module, 'bad_module'))

    76         self.assertRaises(ImportError, import_module, 'egg_module.sub1.sub2.bad_module')

    77 

    78         # A child that doesn't exist

    79         self.assertFalse(module_has_submodule(egg_module, 'no_such_module'))

    80         self.assertRaises(ImportError, import_module, 'egg_module.sub1.sub2.no_such_module')

    81 

    82 class TestFinder(object):

    83     def __init__(self, *args, **kwargs):

    84         self.importer = zipimporter(*args, **kwargs)

    85 

    86     def find_module(self, path):

    87         importer = self.importer.find_module(path)

    88         if importer is None:

    89             return

    90         return TestLoader(importer)

    91 

    92 class TestLoader(object):

    93     def __init__(self, importer):

    94         self.importer = importer

    95 

    96     def load_module(self, name):

    97         mod = self.importer.load_module(name)

    98         mod.__loader__ = self

    99         return mod

   100 

   101 class CustomLoader(EggLoader):

   102     """The Custom Loader test is exactly the same as the EggLoader, but

   103     it uses a custom defined Loader and Finder that is intentionally

   104     split into two classes. Although the EggLoader combines both functions

   105     into one class, this isn't required.

   106     """

   107     def setUp(self):

   108         super(CustomLoader, self).setUp()

   109         sys.path_hooks.insert(0, TestFinder)

   110         sys.path_importer_cache.clear()

   111 

   112     def tearDown(self):

   113         super(CustomLoader, self).tearDown()

   114         sys.path_hooks.pop(0)