1 import __future__

     2 import os

     3 import unittest

     4 import distutils.dir_util

     5 import tempfile

     6 

     7 from test import test_support

     8 

     9 try: set

    10 except NameError: from sets import Set as set

    11 

    12 import modulefinder

    13 

    14 # Note: To test modulefinder with Python 2.2, sets.py and

    15 # modulefinder.py must be available - they are not in the standard

    16 # library.

    17 

    18 TEST_DIR = tempfile.mkdtemp()

    19 TEST_PATH = [TEST_DIR, os.path.dirname(__future__.__file__)]

    20 

    21 # Each test description is a list of 5 items:

    22 #

    23 # 1. a module name that will be imported by modulefinder

    24 # 2. a list of module names that modulefinder is required to find

    25 # 3. a list of module names that modulefinder should complain

    26 #    about because they are not found

    27 # 4. a list of module names that modulefinder should complain

    28 #    about because they MAY be not found

    29 # 5. a string specifying packages to create; the format is obvious imo.

    30 #

    31 # Each package will be created in TEST_DIR, and TEST_DIR will be

    32 # removed after the tests again.

    33 # Modulefinder searches in a path that contains TEST_DIR, plus

    34 # the standard Lib directory.

    35 

    36 maybe_test = [

    37     "a.module",

    38     ["a", "a.module", "sys",

    39      "b"],

    40     ["c"], ["b.something"],

    41     """\

    42 a/__init__.py

    43 a/module.py

    44                                 from b import something

    45                                 from c import something

    46 b/__init__.py

    47                                 from sys import *

    48 """]

    49 

    50 maybe_test_new = [

    51     "a.module",

    52     ["a", "a.module", "sys",

    53      "b", "__future__"],

    54     ["c"], ["b.something"],

    55     """\

    56 a/__init__.py

    57 a/module.py

    58                                 from b import something

    59                                 from c import something

    60 b/__init__.py

    61                                 from __future__ import absolute_import

    62                                 from sys import *

    63 """]

    64 

    65 package_test = [

    66     "a.module",

    67     ["a", "a.b", "a.c", "a.module", "mymodule", "sys"],

    68     ["blahblah"], [],

    69     """\

    70 mymodule.py

    71 a/__init__.py

    72                                 import blahblah

    73                                 from a import b

    74                                 import c

    75 a/module.py

    76                                 import sys

    77                                 from a import b as x

    78                                 from a.c import sillyname

    79 a/b.py

    80 a/c.py

    81                                 from a.module import x

    82                                 import mymodule as sillyname

    83                                 from sys import version_info

    84 """]

    85 

    86 absolute_import_test = [

    87     "a.module",

    88     ["a", "a.module",

    89      "b", "b.x", "b.y", "b.z",

    90      "__future__", "sys", "exceptions"],

    91     ["blahblah"], [],

    92     """\

    93 mymodule.py

    94 a/__init__.py

    95 a/module.py

    96                                 from __future__ import absolute_import

    97                                 import sys # sys

    98                                 import blahblah # fails

    99                                 import exceptions # exceptions

   100                                 import b.x # b.x

   101                                 from b import y # b.y

   102                                 from b.z import * # b.z.*

   103 a/exceptions.py

   104 a/sys.py

   105                                 import mymodule

   106 a/b/__init__.py

   107 a/b/x.py

   108 a/b/y.py

   109 a/b/z.py

   110 b/__init__.py

   111                                 import z

   112 b/unused.py

   113 b/x.py

   114 b/y.py

   115 b/z.py

   116 """]

   117 

   118 relative_import_test = [

   119     "a.module",

   120     ["__future__",

   121      "a", "a.module",

   122      "a.b", "a.b.y", "a.b.z",

   123      "a.b.c", "a.b.c.moduleC",

   124      "a.b.c.d", "a.b.c.e",

   125      "a.b.x",

   126      "exceptions"],

   127     [], [],

   128     """\

   129 mymodule.py

   130 a/__init__.py

   131                                 from .b import y, z # a.b.y, a.b.z

   132 a/module.py

   133                                 from __future__ import absolute_import # __future__

   134                                 import exceptions # exceptions

   135 a/exceptions.py

   136 a/sys.py

   137 a/b/__init__.py

   138                                 from ..b import x # a.b.x

   139                                 #from a.b.c import moduleC

   140                                 from .c import moduleC # a.b.moduleC

   141 a/b/x.py

   142 a/b/y.py

   143 a/b/z.py

   144 a/b/g.py

   145 a/b/c/__init__.py

   146                                 from ..c import e # a.b.c.e

   147 a/b/c/moduleC.py

   148                                 from ..c import d # a.b.c.d

   149 a/b/c/d.py

   150 a/b/c/e.py

   151 a/b/c/x.py

   152 """]

   153 

   154 relative_import_test_2 = [

   155     "a.module",

   156     ["a", "a.module",

   157      "a.sys",

   158      "a.b", "a.b.y", "a.b.z",

   159      "a.b.c", "a.b.c.d",

   160      "a.b.c.e",

   161      "a.b.c.moduleC",

   162      "a.b.c.f",

   163      "a.b.x",

   164      "a.another"],

   165     [], [],

   166     """\

   167 mymodule.py

   168 a/__init__.py

   169                                 from . import sys # a.sys

   170 a/another.py

   171 a/module.py

   172                                 from .b import y, z # a.b.y, a.b.z

   173 a/exceptions.py

   174 a/sys.py

   175 a/b/__init__.py

   176                                 from .c import moduleC # a.b.c.moduleC

   177                                 from .c import d # a.b.c.d

   178 a/b/x.py

   179 a/b/y.py

   180 a/b/z.py

   181 a/b/c/__init__.py

   182                                 from . import e # a.b.c.e

   183 a/b/c/moduleC.py

   184                                 #

   185                                 from . import f   # a.b.c.f

   186                                 from .. import x  # a.b.x

   187                                 from ... import another # a.another

   188 a/b/c/d.py

   189 a/b/c/e.py

   190 a/b/c/f.py

   191 """]

   192 

   193 relative_import_test_3 = [

   194     "a.module",

   195     ["a", "a.module"],

   196     ["a.bar"],

   197     [],

   198     """\

   199 a/__init__.py

   200                                 def foo(): pass

   201 a/module.py

   202                                 from . import foo

   203                                 from . import bar

   204 """]

   205 

   206 def open_file(path):

   207     ##print "#", os.path.abspath(path)

   208     dirname = os.path.dirname(path)

   209     distutils.dir_util.mkpath(dirname)

   210     return open(path, "w")

   211 

   212 def create_package(source):

   213     ofi = None

   214     for line in source.splitlines():

   215         if line.startswith(" ") or line.startswith("\t"):

   216             ofi.write(line.strip() + "\n")

   217         else:

   218             ofi = open_file(os.path.join(TEST_DIR, line.strip()))

   219 

   220 class ModuleFinderTest(unittest.TestCase):

   221     def _do_test(self, info, report=False):

   222         import_this, modules, missing, maybe_missing, source = info

   223         create_package(source)

   224         try:

   225             mf = modulefinder.ModuleFinder(path=TEST_PATH)

   226             mf.import_hook(import_this)

   227             if report:

   228                 mf.report()

   229 ##                # This wouldn't work in general when executed several times:

   230 ##                opath = sys.path[:]

   231 ##                sys.path = TEST_PATH

   232 ##                try:

   233 ##                    __import__(import_this)

   234 ##                except:

   235 ##                    import traceback; traceback.print_exc()

   236 ##                sys.path = opath

   237 ##                return

   238             modules = set(modules)

   239             found = set(mf.modules.keys())

   240             more = list(found - modules)

   241             less = list(modules - found)

   242             # check if we found what we expected, not more, not less

   243             self.failUnlessEqual((more, less), ([], []))

   244 

   245             # check for missing and maybe missing modules

   246             bad, maybe = mf.any_missing_maybe()

   247             self.failUnlessEqual(bad, missing)

   248             self.failUnlessEqual(maybe, maybe_missing)

   249         finally:

   250             distutils.dir_util.remove_tree(TEST_DIR)

   251 

   252     def test_package(self):

   253         self._do_test(package_test)

   254 

   255     def test_maybe(self):

   256         self._do_test(maybe_test)

   257 

   258     if getattr(__future__, "absolute_import", None):

   259 

   260         def test_maybe_new(self):

   261             self._do_test(maybe_test_new)

   262 

   263         def test_absolute_imports(self):

   264             self._do_test(absolute_import_test)

   265 

   266         def test_relative_imports(self):

   267             self._do_test(relative_import_test)

   268 

   269         def test_relative_imports_2(self):

   270             self._do_test(relative_import_test_2)

   271 

   272         def test_relative_imports_3(self):

   273             self._do_test(relative_import_test_3)

   274 

   275 def test_main():

   276     distutils.log.set_threshold(distutils.log.WARN)

   277     test_support.run_unittest(ModuleFinderTest)

   278 

   279 if __name__ == "__main__":

   280     unittest.main()