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, run_unittest, TESTFN

     9 import __builtin__

    10 import os

    11 import sys

    12 import encodings

    13 import subprocess

    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 if not os.path.isdir(site.USER_SITE):

    23     # need to add user site directory for tests

    24     os.makedirs(site.USER_SITE)

    25     site.addsitedir(site.USER_SITE)

    26 

    27 class HelperFunctionsTests(unittest.TestCase):

    28     """Tests for helper functions.

    29 

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

    31     the Unicode implementation is not tested.

    32 

    33     """

    34 

    35     def setUp(self):

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

    37         self.sys_path = sys.path[:]

    38 

    39     def tearDown(self):

    40         """Restore sys.path"""

    41         sys.path = self.sys_path

    42 

    43     def test_makepath(self):

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

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

    46         # second value.

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

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

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

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

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

    52             self.failUnlessEqual(abs_dir, norm_dir)

    53         else:

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

    55 

    56     def test_init_pathinfo(self):

    57         dir_set = site._init_pathinfo()

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

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

    60             self.failUnless(entry in dir_set,

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

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

    63 

    64     def pth_file_tests(self, pth_file):

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

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

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

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

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

    70 

    71     def test_addpackage(self):

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

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

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

    75         # file resides; invalid directories are not added

    76         pth_file = PthFile()

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

    78                                       # pre-existing that shouldn't be

    79         try:

    80             pth_file.create()

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

    82             self.pth_file_tests(pth_file)

    83         finally:

    84             pth_file.cleanup()

    85 

    86     def test_addsitedir(self):

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

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

    89         pth_file = PthFile()

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

    91                                     # that is tested for

    92         try:

    93             pth_file.create()

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

    95             self.pth_file_tests(pth_file)

    96         finally:

    97             pth_file.cleanup()

    98 

    99     def test_s_option(self):

   100         usersite = site.USER_SITE

   101         self.assert_(usersite in sys.path)

   102 

   103         rc = subprocess.call([sys.executable, '-c',

   104             'import sys; sys.exit(%r in sys.path)' % usersite])

   105         self.assertEqual(rc, 1)

   106 

   107         rc = subprocess.call([sys.executable, '-s', '-c',

   108             'import sys; sys.exit(%r in sys.path)' % usersite])

   109         self.assertEqual(rc, 0)

   110 

   111         env = os.environ.copy()

   112         env["PYTHONNOUSERSITE"] = "1"

   113         rc = subprocess.call([sys.executable, '-c',

   114             'import sys; sys.exit(%r in sys.path)' % usersite],

   115             env=env)

   116         self.assertEqual(rc, 0)

   117 

   118         env = os.environ.copy()

   119         env["PYTHONUSERBASE"] = "/tmp"

   120         rc = subprocess.call([sys.executable, '-c',

   121             'import sys, site; sys.exit(site.USER_BASE.startswith("/tmp"))'],

   122             env=env)

   123         self.assertEqual(rc, 1)

   124 

   125 

   126 class PthFile(object):

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

   128 

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

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

   131         """Initialize instance variables"""

   132         self.filename = filename_base + ".pth"

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

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

   135         self.imported = imported

   136         self.good_dirname = good_dirname

   137         self.bad_dirname = bad_dirname

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

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

   140 

   141     def create(self):

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

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

   144         self.bad_dirname.

   145 

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

   147         self.good_dirname) is also performed.

   148 

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

   150 

   151         """

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

   153         try:

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

   155             print>>FILE, "\n"

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

   157             print>>FILE, self.good_dirname

   158             print>>FILE, self.bad_dirname

   159         finally:

   160             FILE.close()

   161         os.mkdir(self.good_dir_path)

   162 

   163     def cleanup(self, prep=False):

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

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

   166         not existing directories."""

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

   168             os.remove(self.file_path)

   169         if prep:

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

   171             if self.imported_module:

   172                 del sys.modules[self.imported]

   173         else:

   174             if self.imported_module:

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

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

   177             os.rmdir(self.good_dir_path)

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

   179             os.rmdir(self.bad_dir_path)

   180 

   181 class ImportSideEffectTests(unittest.TestCase):

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

   183 

   184     def setUp(self):

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

   186         self.sys_path = sys.path[:]

   187 

   188     def tearDown(self):

   189         """Restore sys.path"""

   190         sys.path = self.sys_path

   191 

   192     def test_abs__file__(self):

   193         # Make sure all imported modules have their __file__ attribute

   194         # as an absolute path.

   195         # Handled by abs__file__()

   196         site.abs__file__()

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

   198             try:

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

   200             except AttributeError:

   201                 continue

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

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

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

   205 

   206     def test_no_duplicate_paths(self):

   207         # No duplicate paths should exist in sys.path

   208         # Handled by removeduppaths()

   209         site.removeduppaths()

   210         seen_paths = set()

   211         for path in sys.path:

   212             self.failUnless(path not in seen_paths)

   213             seen_paths.add(path)

   214 

   215     def test_add_build_dir(self):

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

   217         # should be.

   218         # XXX: implement

   219         pass

   220 

   221     def test_setting_quit(self):

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

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

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

   225 

   226     def test_setting_copyright(self):

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

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

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

   230 

   231     def test_setting_help(self):

   232         # 'help' should be set in __builtin__

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

   234 

   235     def test_aliasing_mbcs(self):

   236         if sys.platform == "win32":

   237             import locale

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

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

   240                     if value == "mbcs":

   241                         break

   242                 else:

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

   244 

   245     def test_setdefaultencoding_removed(self):

   246         # Make sure sys.setdefaultencoding is gone

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

   248 

   249     def test_sitecustomize_executed(self):

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

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

   252             try:

   253                 import sitecustomize

   254             except ImportError:

   255                 pass

   256             else:

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

   258 

   259 def test_main():

   260     run_unittest(HelperFunctionsTests, ImportSideEffectTests)

   261 

   262 if __name__ == "__main__":

   263     test_main()