Lib/test/test_site.py

   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 run_unittest, TESTFN, EnvironmentVarGuard
   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 unittest.SkipTest("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         self.old_base = site.USER_BASE
  39         self.old_site = site.USER_SITE
  40         self.old_prefixes = site.PREFIXES
  41
  42     def tearDown(self):
  43         """Restore sys.path"""
  44         sys.path[:] = self.sys_path
  45         site.USER_BASE = self.old_base
  46         site.USER_SITE = self.old_site
  47         site.PREFIXES = self.old_prefixes
  48
  49     def test_makepath(self):
  50         # Test makepath() have an absolute path for its first return value
  51         # and a case-normalized version of the absolute path for its
  52         # second value.
  53         path_parts = ("Beginning", "End")
  54         original_dir = os.path.join(*path_parts)
  55         abs_dir, norm_dir = site.makepath(*path_parts)
  56         self.assertEqual(os.path.abspath(original_dir), abs_dir)
  57         if original_dir == os.path.normcase(original_dir):
  58             self.assertEqual(abs_dir, norm_dir)
  59         else:
  60             self.assertEqual(os.path.normcase(abs_dir), norm_dir)
  61
  62     def test_init_pathinfo(self):
  63         dir_set = site._init_pathinfo()
  64         for entry in [site.makepath(path)[1] for path in sys.path
  65                         if path and os.path.isdir(path)]:
  66             self.assertTrue(entry in dir_set,
  67                             "%s from sys.path not found in set returned "
  68                             "by _init_pathinfo(): %s" % (entry, dir_set))
  69
  70     def pth_file_tests(self, pth_file):
  71         """Contain common code for testing results of reading a .pth file"""
  72         self.assertTrue(pth_file.imported in sys.modules,
  73                 "%s not in sys.modules" % pth_file.imported)
  74         self.assertIn(site.makepath(pth_file.good_dir_path)[0], sys.path)
  75         self.assertFalse(os.path.exists(pth_file.bad_dir_path))
  76
  77     def test_addpackage(self):
  78         # Make sure addpackage() imports if the line starts with 'import',
  79         # adds directories to sys.path for any line in the file that is not a
  80         # comment or import that is a valid directory name for where the .pth
  81         # file resides; invalid directories are not added
  82         pth_file = PthFile()
  83         pth_file.cleanup(prep=True)  # to make sure that nothing is
  84                                       # pre-existing that shouldn't be
  85         try:
  86             pth_file.create()
  87             site.addpackage(pth_file.base_dir, pth_file.filename, set())
  88             self.pth_file_tests(pth_file)
  89         finally:
  90             pth_file.cleanup()
  91
  92     def test_addsitedir(self):
  93         # Same tests for test_addpackage since addsitedir() essentially just
  94         # calls addpackage() for every .pth file in the directory
  95         pth_file = PthFile()
  96         pth_file.cleanup(prep=True) # Make sure that nothing is pre-existing
  97                                     # that is tested for
  98         try:
  99             pth_file.create()
 100             site.addsitedir(pth_file.base_dir, set())
 101             self.pth_file_tests(pth_file)
 102         finally:
 103             pth_file.cleanup()
 104
 105     def test_s_option(self):
 106         usersite = site.USER_SITE
 107         self.assertIn(usersite, sys.path)
 108
 109         rc = subprocess.call([sys.executable, '-c',
 110             'import sys; sys.exit(%r in sys.path)' % usersite])
 111         self.assertEqual(rc, 1, "%r is not in sys.path (sys.exit returned %r)"
 112                 % (usersite, rc))
 113
 114         rc = subprocess.call([sys.executable, '-s', '-c',
 115             'import sys; sys.exit(%r in sys.path)' % usersite])
 116         self.assertEqual(rc, 0)
 117
 118         env = os.environ.copy()
 119         env["PYTHONNOUSERSITE"] = "1"
 120         rc = subprocess.call([sys.executable, '-c',
 121             'import sys; sys.exit(%r in sys.path)' % usersite],
 122             env=env)
 123         self.assertEqual(rc, 0)
 124
 125         env = os.environ.copy()
 126         env["PYTHONUSERBASE"] = "/tmp"
 127         rc = subprocess.call([sys.executable, '-c',
 128             'import sys, site; sys.exit(site.USER_BASE.startswith("/tmp"))'],
 129             env=env)
 130         self.assertEqual(rc, 1)
 131
 132     def test_getuserbase(self):
 133         site.USER_BASE = None
 134         user_base = site.getuserbase()
 135
 136         # the call sets site.USER_BASE
 137         self.assertEquals(site.USER_BASE, user_base)
 138
 139         # let's set PYTHONUSERBASE and see if it uses it
 140         site.USER_BASE = None
 141         with EnvironmentVarGuard() as environ:
 142             environ['PYTHONUSERBASE'] = 'xoxo'
 143             self.assertTrue(site.getuserbase().startswith('xoxo'),
 144                             site.getuserbase())
 145
 146     def test_getusersitepackages(self):
 147         site.USER_SITE = None
 148         site.USER_BASE = None
 149         user_site = site.getusersitepackages()
 150
 151         # the call sets USER_BASE *and* USER_SITE
 152         self.assertEquals(site.USER_SITE, user_site)
 153         self.assertTrue(user_site.startswith(site.USER_BASE), user_site)
 154
 155     def test_getsitepackages(self):
 156         site.PREFIXES = ['xoxo']
 157         dirs = site.getsitepackages()
 158
 159         if sys.platform in ('os2emx', 'riscos'):
 160             self.assertEqual(len(dirs), 1)
 161             wanted = os.path.join('xoxo', 'Lib', 'site-packages')
 162             self.assertEquals(dirs[0], wanted)
 163         elif os.sep == '/':
 164             self.assertTrue(len(dirs), 2)
 165             wanted = os.path.join('xoxo', 'lib', 'python' + sys.version[:3],
 166                                   'site-packages')
 167             self.assertEquals(dirs[0], wanted)
 168             wanted = os.path.join('xoxo', 'lib', 'site-python')
 169             self.assertEquals(dirs[1], wanted)
 170         else:
 171             self.assertTrue(len(dirs), 2)
 172             self.assertEquals(dirs[0], 'xoxo')
 173             wanted = os.path.join('xoxo', 'lib', 'site-packages')
 174             self.assertEquals(dirs[1], wanted)
 175
 176         # let's try the specific Apple location
 177         if sys.platform == "darwin":
 178             site.PREFIXES = ['Python.framework']
 179             dirs = site.getsitepackages()
 180             self.assertEqual(len(dirs), 4)
 181             wanted = os.path.join('~', 'Library', 'Python',
 182                                   sys.version[:3], 'site-packages')
 183             self.assertEquals(dirs[2], os.path.expanduser(wanted))
 184             wanted = os.path.join('/Library', 'Python', sys.version[:3],
 185                                   'site-packages')
 186             self.assertEquals(dirs[3], wanted)
 187
 188 class PthFile(object):
 189     """Helper class for handling testing of .pth files"""
 190
 191     def __init__(self, filename_base=TESTFN, imported="time",
 192                     good_dirname="__testdir__", bad_dirname="__bad"):
 193         """Initialize instance variables"""
 194         self.filename = filename_base + ".pth"
 195         self.base_dir = os.path.abspath('')
 196         self.file_path = os.path.join(self.base_dir, self.filename)
 197         self.imported = imported
 198         self.good_dirname = good_dirname
 199         self.bad_dirname = bad_dirname
 200         self.good_dir_path = os.path.join(self.base_dir, self.good_dirname)
 201         self.bad_dir_path = os.path.join(self.base_dir, self.bad_dirname)
 202
 203     def create(self):
 204         """Create a .pth file with a comment, blank lines, an ``import
 205         <self.imported>``, a line with self.good_dirname, and a line with
 206         self.bad_dirname.
 207
 208         Creation of the directory for self.good_dir_path (based off of
 209         self.good_dirname) is also performed.
 210
 211         Make sure to call self.cleanup() to undo anything done by this method.
 212
 213         """
 214         FILE = open(self.file_path, 'w')
 215         try:
 216             print>>FILE, "#import @bad module name"
 217             print>>FILE, "\n"
 218             print>>FILE, "import %s" % self.imported
 219             print>>FILE, self.good_dirname
 220             print>>FILE, self.bad_dirname
 221         finally:
 222             FILE.close()
 223         os.mkdir(self.good_dir_path)
 224
 225     def cleanup(self, prep=False):
 226         """Make sure that the .pth file is deleted, self.imported is not in
 227         sys.modules, and that both self.good_dirname and self.bad_dirname are
 228         not existing directories."""
 229         if os.path.exists(self.file_path):
 230             os.remove(self.file_path)
 231         if prep:
 232             self.imported_module = sys.modules.get(self.imported)
 233             if self.imported_module:
 234                 del sys.modules[self.imported]
 235         else:
 236             if self.imported_module:
 237                 sys.modules[self.imported] = self.imported_module
 238         if os.path.exists(self.good_dir_path):
 239             os.rmdir(self.good_dir_path)
 240         if os.path.exists(self.bad_dir_path):
 241             os.rmdir(self.bad_dir_path)
 242
 243 class ImportSideEffectTests(unittest.TestCase):
 244     """Test side-effects from importing 'site'."""
 245
 246     def setUp(self):
 247         """Make a copy of sys.path"""
 248         self.sys_path = sys.path[:]
 249
 250     def tearDown(self):
 251         """Restore sys.path"""
 252         sys.path[:] = self.sys_path
 253
 254     def test_abs__file__(self):
 255         # Make sure all imported modules have their __file__ attribute
 256         # as an absolute path.
 257         # Handled by abs__file__()
 258         site.abs__file__()
 259         for module in (sys, os, __builtin__):
 260             try:
 261                 self.assertTrue(os.path.isabs(module.__file__), `module`)
 262             except AttributeError:
 263                 continue
 264         # We could try everything in sys.modules; however, when regrtest.py
 265         # runs something like test_frozen before test_site, then we will
 266         # be testing things loaded *after* test_site did path normalization
 267
 268     def test_no_duplicate_paths(self):
 269         # No duplicate paths should exist in sys.path
 270         # Handled by removeduppaths()
 271         site.removeduppaths()
 272         seen_paths = set()
 273         for path in sys.path:
 274             self.assertTrue(path not in seen_paths)
 275             seen_paths.add(path)
 276
 277     def test_add_build_dir(self):
 278         # Test that the build directory's Modules directory is used when it
 279         # should be.
 280         # XXX: implement
 281         pass
 282
 283     def test_setting_quit(self):
 284         # 'quit' and 'exit' should be injected into __builtin__
 285         self.assertTrue(hasattr(__builtin__, "quit"))
 286         self.assertTrue(hasattr(__builtin__, "exit"))
 287
 288     def test_setting_copyright(self):
 289         # 'copyright' and 'credits' should be in __builtin__
 290         self.assertTrue(hasattr(__builtin__, "copyright"))
 291         self.assertTrue(hasattr(__builtin__, "credits"))
 292
 293     def test_setting_help(self):
 294         # 'help' should be set in __builtin__
 295         self.assertTrue(hasattr(__builtin__, "help"))
 296
 297     def test_aliasing_mbcs(self):
 298         if sys.platform == "win32":
 299             import locale
 300             if locale.getdefaultlocale()[1].startswith('cp'):
 301                 for value in encodings.aliases.aliases.itervalues():
 302                     if value == "mbcs":
 303                         break
 304                 else:
 305                     self.fail("did not alias mbcs")
 306
 307     def test_setdefaultencoding_removed(self):
 308         # Make sure sys.setdefaultencoding is gone
 309         self.assertTrue(not hasattr(sys, "setdefaultencoding"))
 310
 311     def test_sitecustomize_executed(self):
 312         # If sitecustomize is available, it should have been imported.
 313         if not sys.modules.has_key("sitecustomize"):
 314             try:
 315                 import sitecustomize
 316             except ImportError:
 317                 pass
 318             else:
 319                 self.fail("sitecustomize not imported automatically")
 320
 321 def test_main():
 322     run_unittest(HelperFunctionsTests, ImportSideEffectTests)
 323
 324 if __name__ == "__main__":
 325     test_main()