1 """Tests for 'site'.

     2 

     3 Tests assume the initial paths in sys.path once the interpreter has begun

     4 executing have not been removed.

     5 

     6 """

     7 import unittest

     8 from test.test_support import TestSkipped, TestFailed, run_unittest, TESTFN

     9 import __builtin__

    10 import os

    11 import sys

    12 import encodings

    13 import tempfile

    14 # Need to make sure to not import 'site' if someone specified ``-S`` at the

    15 # command-line.  Detect this by just making sure 'site' has not been imported

    16 # already.

    17 if "site" in sys.modules:

    18     import site

    19 else:

    20     raise TestSkipped("importation of site.py suppressed")

    21 

    22 class HelperFunctionsTests(unittest.TestCase):

    23     """Tests for helper functions.

    24 

    25     The setting of the encoding (set using sys.setdefaultencoding) used by

    26     the Unicode implementation is not tested.

    27 

    28     """

    29 

    30     def setUp(self):

    31         """Save a copy of sys.path"""

    32         self.sys_path = sys.path[:]

    33 

    34     def tearDown(self):

    35         """Restore sys.path"""

    36         sys.path = self.sys_path

    37 

    38     def test_makepath(self):

    39         # Test makepath() have an absolute path for its first return value

    40         # and a case-normalized version of the absolute path for its

    41         # second value.

    42         path_parts = ("Beginning", "End")

    43         original_dir = os.path.join(*path_parts)

    44         abs_dir, norm_dir = site.makepath(*path_parts)

    45         self.failUnlessEqual(os.path.abspath(original_dir), abs_dir)

    46         if original_dir == os.path.normcase(original_dir):

    47             self.failUnlessEqual(abs_dir, norm_dir)

    48         else:

    49             self.failUnlessEqual(os.path.normcase(abs_dir), norm_dir)

    50 

    51     def test_init_pathinfo(self):

    52         dir_set = site._init_pathinfo()

    53         for entry in [site.makepath(path)[1] for path in sys.path

    54                         if path and os.path.isdir(path)]:

    55             self.failUnless(entry in dir_set,

    56                             "%s from sys.path not found in set returned "

    57                             "by _init_pathinfo(): %s" % (entry, dir_set))

    58 

    59     def pth_file_tests(self, pth_file):

    60         """Contain common code for testing results of reading a .pth file"""

    61         self.failUnless(pth_file.imported in sys.modules,

    62                 "%s not in sys.path" % pth_file.imported)

    63         self.failUnless(site.makepath(pth_file.good_dir_path)[0] in sys.path)

    64         self.failUnless(not os.path.exists(pth_file.bad_dir_path))

    65 

    66     def test_addpackage(self):

    67         # Make sure addpackage() imports if the line starts with 'import',

    68         # adds directories to sys.path for any line in the file that is not a

    69         # comment or import that is a valid directory name for where the .pth

    70         # file resides; invalid directories are not added

    71         pth_file = PthFile()

    72         pth_file.cleanup(prep=True)  # to make sure that nothing is

    73                                       # pre-existing that shouldn't be

    74         try:

    75             pth_file.create()

    76             site.addpackage(pth_file.base_dir, pth_file.filename, set())

    77             self.pth_file_tests(pth_file)

    78         finally:

    79             pth_file.cleanup()

    80 

    81     def test_addsitedir(self):

    82         # Same tests for test_addpackage since addsitedir() essentially just

    83         # calls addpackage() for every .pth file in the directory

    84         pth_file = PthFile()

    85         pth_file.cleanup(prep=True) # Make sure that nothing is pre-existing

    86                                     # that is tested for

    87         try:

    88             pth_file.create()

    89             site.addsitedir(pth_file.base_dir, set())

    90             self.pth_file_tests(pth_file)

    91         finally:

    92             pth_file.cleanup()

    93 

    94 class PthFile(object):

    95     """Helper class for handling testing of .pth files"""

    96 

    97     def __init__(self, filename_base=TESTFN, imported="time",

    98                     good_dirname="__testdir__", bad_dirname="__bad"):

    99         """Initialize instance variables"""

   100         self.filename = filename_base + ".pth"

   101         self.base_dir = os.path.abspath('')

   102         self.file_path = os.path.join(self.base_dir, self.filename)

   103         self.imported = imported

   104         self.good_dirname = good_dirname

   105         self.bad_dirname = bad_dirname

   106         self.good_dir_path = os.path.join(self.base_dir, self.good_dirname)

   107         self.bad_dir_path = os.path.join(self.base_dir, self.bad_dirname)

   108 

   109     def create(self):

   110         """Create a .pth file with a comment, blank lines, an ``import

   111         <self.imported>``, a line with self.good_dirname, and a line with

   112         self.bad_dirname.

   113 

   114         Creation of the directory for self.good_dir_path (based off of

   115         self.good_dirname) is also performed.

   116 

   117         Make sure to call self.cleanup() to undo anything done by this method.

   118 

   119         """

   120         FILE = open(self.file_path, 'w')

   121         try:

   122             print>>FILE, "#import @bad module name"

   123             print>>FILE, "\n"

   124             print>>FILE, "import %s" % self.imported

   125             print>>FILE, self.good_dirname

   126             print>>FILE, self.bad_dirname

   127         finally:

   128             FILE.close()

   129         os.mkdir(self.good_dir_path)

   130 

   131     def cleanup(self, prep=False):

   132         """Make sure that the .pth file is deleted, self.imported is not in

   133         sys.modules, and that both self.good_dirname and self.bad_dirname are

   134         not existing directories."""

   135         if os.path.exists(self.file_path):

   136             os.remove(self.file_path)

   137         if prep:

   138             self.imported_module = sys.modules.get(self.imported)

   139             if self.imported_module:

   140                 del sys.modules[self.imported]

   141         else:

   142             if self.imported_module:

   143                 sys.modules[self.imported] = self.imported_module

   144         if os.path.exists(self.good_dir_path):

   145             os.rmdir(self.good_dir_path)

   146         if os.path.exists(self.bad_dir_path):

   147             os.rmdir(self.bad_dir_path)

   148 

   149 class ImportSideEffectTests(unittest.TestCase):

   150     """Test side-effects from importing 'site'."""

   151 

   152     def setUp(self):

   153         """Make a copy of sys.path"""

   154         self.sys_path = sys.path[:]

   155 

   156     def tearDown(self):

   157         """Restore sys.path"""

   158         sys.path = self.sys_path

   159 

   160     def test_abs__file__(self):

   161         # Make sure all imported modules have their __file__ attribute

   162         # as an absolute path.

   163         # Handled by abs__file__()

   164         site.abs__file__()

   165         for module in (sys, os, __builtin__):

   166             try:

   167                 self.failUnless(os.path.isabs(module.__file__), `module`)

   168             except AttributeError:

   169                 continue

   170         # We could try everything in sys.modules; however, when regrtest.py

   171         # runs something like test_frozen before test_site, then we will

   172         # be testing things loaded *after* test_site did path normalization

   173 

   174     def test_no_duplicate_paths(self):

   175         # No duplicate paths should exist in sys.path

   176         # Handled by removeduppaths()

   177         site.removeduppaths()

   178         seen_paths = set()

   179         for path in sys.path:

   180             self.failUnless(path not in seen_paths)

   181             seen_paths.add(path)

   182 

   183     def test_add_build_dir(self):

   184         # Test that the build directory's Modules directory is used when it

   185         # should be.

   186         # XXX: implement

   187         pass

   188 

   189     def test_setting_quit(self):

   190         # 'quit' and 'exit' should be injected into __builtin__

   191         self.failUnless(hasattr(__builtin__, "quit"))

   192         self.failUnless(hasattr(__builtin__, "exit"))

   193 

   194     def test_setting_copyright(self):

   195         # 'copyright' and 'credits' should be in __builtin__

   196         self.failUnless(hasattr(__builtin__, "copyright"))

   197         self.failUnless(hasattr(__builtin__, "credits"))

   198 

   199     def test_setting_help(self):

   200         # 'help' should be set in __builtin__

   201         self.failUnless(hasattr(__builtin__, "help"))

   202 

   203     def test_aliasing_mbcs(self):

   204         if sys.platform == "win32":

   205             import locale

   206             if locale.getdefaultlocale()[1].startswith('cp'):

   207                 for value in encodings.aliases.aliases.itervalues():

   208                     if value == "mbcs":

   209                         break

   210                 else:

   211                     self.fail("did not alias mbcs")

   212 

   213     def test_setdefaultencoding_removed(self):

   214         # Make sure sys.setdefaultencoding is gone

   215         self.failUnless(not hasattr(sys, "setdefaultencoding"))

   216 

   217     def test_sitecustomize_executed(self):

   218         # If sitecustomize is available, it should have been imported.

   219         if not sys.modules.has_key("sitecustomize"):

   220             try:

   221                 import sitecustomize

   222             except ImportError:

   223                 pass

   224             else:

   225                 self.fail("sitecustomize not imported automatically")

   226 

   227 

   228 

   229 

   230 def test_main():

   231     run_unittest(HelperFunctionsTests, ImportSideEffectTests)

   232 

   233 

   234 

   235 if __name__ == "__main__":

   236     test_main()