Lib/test/test_tempfile.py

   1 # tempfile.py unit tests.
   2
   3 import tempfile
   4 import os
   5 import sys
   6 import re
   7 import errno
   8 import warnings
   9
  10 import unittest
  11 from test import test_support
  12
  13 if hasattr(os, 'stat'):
  14     import stat
  15     has_stat = 1
  16 else:
  17     has_stat = 0
  18
  19 has_textmode = (tempfile._text_openflags != tempfile._bin_openflags)
  20 has_spawnl = hasattr(os, 'spawnl')
  21
  22 # TEST_FILES may need to be tweaked for systems depending on the maximum
  23 # number of files that can be opened at one time (see ulimit -n)
  24 TEST_FILES = 100
  25
  26 # This is organized as one test for each chunk of code in tempfile.py,
  27 # in order of their appearance in the file.  Testing which requires
  28 # threads is not done here.
  29
  30 # Common functionality.
  31 class TC(unittest.TestCase):
  32
  33     str_check = re.compile(r"[a-zA-Z0-9_-]{6}$")
  34
  35     def failOnException(self, what, ei=None):
  36         if ei is None:
  37             ei = sys.exc_info()
  38         self.fail("%s raised %s: %s" % (what, ei[0], ei[1]))
  39
  40     def nameCheck(self, name, dir, pre, suf):
  41         (ndir, nbase) = os.path.split(name)
  42         npre  = nbase[:len(pre)]
  43         nsuf  = nbase[len(nbase)-len(suf):]
  44
  45         self.assertEqual(ndir, dir,
  46                          "file '%s' not in directory '%s'" % (name, dir))
  47         self.assertEqual(npre, pre,
  48                          "file '%s' does not begin with '%s'" % (nbase, pre))
  49         self.assertEqual(nsuf, suf,
  50                          "file '%s' does not end with '%s'" % (nbase, suf))
  51
  52         nbase = nbase[len(pre):len(nbase)-len(suf)]
  53         self.assert_(self.str_check.match(nbase),
  54                      "random string '%s' does not match /^[a-zA-Z0-9_-]{6}$/"
  55                      % nbase)
  56
  57 test_classes = []
  58
  59 class test_exports(TC):
  60     def test_exports(self):
  61         # There are no surprising symbols in the tempfile module
  62         dict = tempfile.__dict__
  63
  64         expected = {
  65             "NamedTemporaryFile" : 1,
  66             "TemporaryFile" : 1,
  67             "mkstemp" : 1,
  68             "mkdtemp" : 1,
  69             "mktemp" : 1,
  70             "TMP_MAX" : 1,
  71             "gettempprefix" : 1,
  72             "gettempdir" : 1,
  73             "tempdir" : 1,
  74             "template" : 1
  75         }
  76
  77         unexp = []
  78         for key in dict:
  79             if key[0] != '_' and key not in expected:
  80                 unexp.append(key)
  81         self.failUnless(len(unexp) == 0,
  82                         "unexpected keys: %s" % unexp)
  83
  84 test_classes.append(test_exports)
  85
  86
  87 class test__RandomNameSequence(TC):
  88     """Test the internal iterator object _RandomNameSequence."""
  89
  90     def setUp(self):
  91         self.r = tempfile._RandomNameSequence()
  92
  93     def test_get_six_char_str(self):
  94         # _RandomNameSequence returns a six-character string
  95         s = self.r.next()
  96         self.nameCheck(s, '', '', '')
  97
  98     def test_many(self):
  99         # _RandomNameSequence returns no duplicate strings (stochastic)
 100
 101         dict = {}
 102         r = self.r
 103         for i in xrange(TEST_FILES):
 104             s = r.next()
 105             self.nameCheck(s, '', '', '')
 106             self.failIf(s in dict)
 107             dict[s] = 1
 108
 109     def test_supports_iter(self):
 110         # _RandomNameSequence supports the iterator protocol
 111
 112         i = 0
 113         r = self.r
 114         try:
 115             for s in r:
 116                 i += 1
 117                 if i == 20:
 118                     break
 119         except:
 120             failOnException("iteration")
 121
 122 test_classes.append(test__RandomNameSequence)
 123
 124
 125 class test__candidate_tempdir_list(TC):
 126     """Test the internal function _candidate_tempdir_list."""
 127
 128     def test_nonempty_list(self):
 129         # _candidate_tempdir_list returns a nonempty list of strings
 130
 131         cand = tempfile._candidate_tempdir_list()
 132
 133         self.failIf(len(cand) == 0)
 134         for c in cand:
 135             self.assert_(isinstance(c, basestring),
 136                          "%s is not a string" % c)
 137
 138     def test_wanted_dirs(self):
 139         # _candidate_tempdir_list contains the expected directories
 140
 141         # Make sure the interesting environment variables are all set.
 142         added = []
 143         try:
 144             for envname in 'TMPDIR', 'TEMP', 'TMP':
 145                 dirname = os.getenv(envname)
 146                 if not dirname:
 147                     os.environ[envname] = os.path.abspath(envname)
 148                     added.append(envname)
 149
 150             cand = tempfile._candidate_tempdir_list()
 151
 152             for envname in 'TMPDIR', 'TEMP', 'TMP':
 153                 dirname = os.getenv(envname)
 154                 if not dirname: raise ValueError
 155                 self.assert_(dirname in cand)
 156
 157             try:
 158                 dirname = os.getcwd()
 159             except (AttributeError, os.error):
 160                 dirname = os.curdir
 161
 162             self.assert_(dirname in cand)
 163
 164             # Not practical to try to verify the presence of OS-specific
 165             # paths in this list.
 166         finally:
 167             for p in added:
 168                 del os.environ[p]
 169
 170 test_classes.append(test__candidate_tempdir_list)
 171
 172
 173 # We test _get_default_tempdir by testing gettempdir.
 174
 175
 176 class test__get_candidate_names(TC):
 177     """Test the internal function _get_candidate_names."""
 178
 179     def test_retval(self):
 180         # _get_candidate_names returns a _RandomNameSequence object
 181         obj = tempfile._get_candidate_names()
 182         self.assert_(isinstance(obj, tempfile._RandomNameSequence))
 183
 184     def test_same_thing(self):
 185         # _get_candidate_names always returns the same object
 186         a = tempfile._get_candidate_names()
 187         b = tempfile._get_candidate_names()
 188
 189         self.assert_(a is b)
 190
 191 test_classes.append(test__get_candidate_names)
 192
 193
 194 class test__mkstemp_inner(TC):
 195     """Test the internal function _mkstemp_inner."""
 196
 197     class mkstemped:
 198         _bflags = tempfile._bin_openflags
 199         _tflags = tempfile._text_openflags
 200         _close = os.close
 201         _unlink = os.unlink
 202
 203         def __init__(self, dir, pre, suf, bin):
 204             if bin: flags = self._bflags
 205             else:   flags = self._tflags
 206
 207             (self.fd, self.name) = tempfile._mkstemp_inner(dir, pre, suf, flags)
 208
 209         def write(self, str):
 210             os.write(self.fd, str)
 211
 212         def __del__(self):
 213             self._close(self.fd)
 214             self._unlink(self.name)
 215
 216     def do_create(self, dir=None, pre="", suf="", bin=1):
 217         if dir is None:
 218             dir = tempfile.gettempdir()
 219         try:
 220             file = self.mkstemped(dir, pre, suf, bin)
 221         except:
 222             self.failOnException("_mkstemp_inner")
 223
 224         self.nameCheck(file.name, dir, pre, suf)
 225         return file
 226
 227     def test_basic(self):
 228         # _mkstemp_inner can create files
 229         self.do_create().write("blat")
 230         self.do_create(pre="a").write("blat")
 231         self.do_create(suf="b").write("blat")
 232         self.do_create(pre="a", suf="b").write("blat")
 233         self.do_create(pre="aa", suf=".txt").write("blat")
 234
 235     def test_basic_many(self):
 236         # _mkstemp_inner can create many files (stochastic)
 237         extant = range(TEST_FILES)
 238         for i in extant:
 239             extant[i] = self.do_create(pre="aa")
 240
 241     def test_choose_directory(self):
 242         # _mkstemp_inner can create files in a user-selected directory
 243         dir = tempfile.mkdtemp()
 244         try:
 245             self.do_create(dir=dir).write("blat")
 246         finally:
 247             os.rmdir(dir)
 248
 249     def test_file_mode(self):
 250         # _mkstemp_inner creates files with the proper mode
 251         if not has_stat:
 252             return            # ugh, can't use TestSkipped.
 253
 254         file = self.do_create()
 255         mode = stat.S_IMODE(os.stat(file.name).st_mode)
 256         expected = 0600
 257         if sys.platform in ('win32', 'os2emx'):
 258             # There's no distinction among 'user', 'group' and 'world';
 259             # replicate the 'user' bits.
 260             user = expected >> 6
 261             expected = user * (1 + 8 + 64)
 262         self.assertEqual(mode, expected)
 263
 264     def test_noinherit(self):
 265         # _mkstemp_inner file handles are not inherited by child processes
 266         if not has_spawnl:
 267             return            # ugh, can't use TestSkipped.
 268
 269         if test_support.verbose:
 270             v="v"
 271         else:
 272             v="q"
 273
 274         file = self.do_create()
 275         fd = "%d" % file.fd
 276
 277         try:
 278             me = __file__
 279         except NameError:
 280             me = sys.argv[0]
 281
 282         # We have to exec something, so that FD_CLOEXEC will take
 283         # effect.  The core of this test is therefore in
 284         # tf_inherit_check.py, which see.
 285         tester = os.path.join(os.path.dirname(os.path.abspath(me)),
 286                               "tf_inherit_check.py")
 287
 288         retval = os.spawnl(os.P_WAIT, sys.executable,
 289                            sys.executable, tester, v, fd)
 290         self.failIf(retval < 0,
 291                     "child process caught fatal signal %d" % -retval)
 292         self.failIf(retval > 0, "child process reports failure")
 293
 294     def test_textmode(self):
 295         # _mkstemp_inner can create files in text mode
 296         if not has_textmode:
 297             return            # ugh, can't use TestSkipped.
 298
 299         self.do_create(bin=0).write("blat\n")
 300         # XXX should test that the file really is a text file
 301
 302 test_classes.append(test__mkstemp_inner)
 303
 304
 305 class test_gettempprefix(TC):
 306     """Test gettempprefix()."""
 307
 308     def test_sane_template(self):
 309         # gettempprefix returns a nonempty prefix string
 310         p = tempfile.gettempprefix()
 311
 312         self.assert_(isinstance(p, basestring))
 313         self.assert_(len(p) > 0)
 314
 315     def test_usable_template(self):
 316         # gettempprefix returns a usable prefix string
 317
 318         # Create a temp directory, avoiding use of the prefix.
 319         # Then attempt to create a file whose name is
 320         # prefix + 'xxxxxx.xxx' in that directory.
 321         p = tempfile.gettempprefix() + "xxxxxx.xxx"
 322         d = tempfile.mkdtemp(prefix="")
 323         try:
 324             p = os.path.join(d, p)
 325             try:
 326                 fd = os.open(p, os.O_RDWR | os.O_CREAT)
 327             except:
 328                 self.failOnException("os.open")
 329             os.close(fd)
 330             os.unlink(p)
 331         finally:
 332             os.rmdir(d)
 333
 334 test_classes.append(test_gettempprefix)
 335
 336
 337 class test_gettempdir(TC):
 338     """Test gettempdir()."""
 339
 340     def test_directory_exists(self):
 341         # gettempdir returns a directory which exists
 342
 343         dir = tempfile.gettempdir()
 344         self.assert_(os.path.isabs(dir) or dir == os.curdir,
 345                      "%s is not an absolute path" % dir)
 346         self.assert_(os.path.isdir(dir),
 347                      "%s is not a directory" % dir)
 348
 349     def test_directory_writable(self):
 350         # gettempdir returns a directory writable by the user
 351
 352         # sneaky: just instantiate a NamedTemporaryFile, which
 353         # defaults to writing into the directory returned by
 354         # gettempdir.
 355         try:
 356             file = tempfile.NamedTemporaryFile()
 357             file.write("blat")
 358             file.close()
 359         except:
 360             self.failOnException("create file in %s" % tempfile.gettempdir())
 361
 362     def test_same_thing(self):
 363         # gettempdir always returns the same object
 364         a = tempfile.gettempdir()
 365         b = tempfile.gettempdir()
 366
 367         self.assert_(a is b)
 368
 369 test_classes.append(test_gettempdir)
 370
 371
 372 class test_mkstemp(TC):
 373     """Test mkstemp()."""
 374
 375     def do_create(self, dir=None, pre="", suf="", ):
 376         if dir is None:
 377             dir = tempfile.gettempdir()
 378         try:
 379             (fd, name) = tempfile.mkstemp(dir=dir, prefix=pre, suffix=suf)
 380         except:
 381             self.failOnException("mkstemp")
 382
 383         try:
 384             self.nameCheck(name, dir, pre, suf)
 385         finally:
 386             os.close(fd)
 387             os.unlink(name)
 388
 389     def test_basic(self):
 390         # mkstemp can create files
 391         self.do_create()
 392         self.do_create(pre="a")
 393         self.do_create(suf="b")
 394         self.do_create(pre="a", suf="b")
 395         self.do_create(pre="aa", suf=".txt")
 396
 397     def test_choose_directory(self):
 398         # mkstemp can create directories in a user-selected directory
 399         dir = tempfile.mkdtemp()
 400         try:
 401             self.do_create(dir=dir)
 402         finally:
 403             os.rmdir(dir)
 404
 405 test_classes.append(test_mkstemp)
 406
 407
 408 class test_mkdtemp(TC):
 409     """Test mkdtemp()."""
 410
 411     def do_create(self, dir=None, pre="", suf=""):
 412         if dir is None:
 413             dir = tempfile.gettempdir()
 414         try:
 415             name = tempfile.mkdtemp(dir=dir, prefix=pre, suffix=suf)
 416         except:
 417             self.failOnException("mkdtemp")
 418
 419         try:
 420             self.nameCheck(name, dir, pre, suf)
 421             return name
 422         except:
 423             os.rmdir(name)
 424             raise
 425
 426     def test_basic(self):
 427         # mkdtemp can create directories
 428         os.rmdir(self.do_create())
 429         os.rmdir(self.do_create(pre="a"))
 430         os.rmdir(self.do_create(suf="b"))
 431         os.rmdir(self.do_create(pre="a", suf="b"))
 432         os.rmdir(self.do_create(pre="aa", suf=".txt"))
 433
 434     def test_basic_many(self):
 435         # mkdtemp can create many directories (stochastic)
 436         extant = range(TEST_FILES)
 437         try:
 438             for i in extant:
 439                 extant[i] = self.do_create(pre="aa")
 440         finally:
 441             for i in extant:
 442                 if(isinstance(i, basestring)):
 443                     os.rmdir(i)
 444
 445     def test_choose_directory(self):
 446         # mkdtemp can create directories in a user-selected directory
 447         dir = tempfile.mkdtemp()
 448         try:
 449             os.rmdir(self.do_create(dir=dir))
 450         finally:
 451             os.rmdir(dir)
 452
 453     def test_mode(self):
 454         # mkdtemp creates directories with the proper mode
 455         if not has_stat:
 456             return            # ugh, can't use TestSkipped.
 457
 458         dir = self.do_create()
 459         try:
 460             mode = stat.S_IMODE(os.stat(dir).st_mode)
 461             expected = 0700
 462             if sys.platform in ('win32', 'os2emx'):
 463                 # There's no distinction among 'user', 'group' and 'world';
 464                 # replicate the 'user' bits.
 465                 user = expected >> 6
 466                 expected = user * (1 + 8 + 64)
 467             self.assertEqual(mode, expected)
 468         finally:
 469             os.rmdir(dir)
 470
 471 test_classes.append(test_mkdtemp)
 472
 473
 474 class test_mktemp(TC):
 475     """Test mktemp()."""
 476
 477     # For safety, all use of mktemp must occur in a private directory.
 478     # We must also suppress the RuntimeWarning it generates.
 479     def setUp(self):
 480         self.dir = tempfile.mkdtemp()
 481         warnings.filterwarnings("ignore",
 482                                 category=RuntimeWarning,
 483                                 message="mktemp")
 484
 485     def tearDown(self):
 486         if self.dir:
 487             os.rmdir(self.dir)
 488             self.dir = None
 489         # XXX This clobbers any -W options.
 490         warnings.resetwarnings()
 491
 492     class mktemped:
 493         _unlink = os.unlink
 494         _bflags = tempfile._bin_openflags
 495
 496         def __init__(self, dir, pre, suf):
 497             self.name = tempfile.mktemp(dir=dir, prefix=pre, suffix=suf)
 498             # Create the file.  This will raise an exception if it's
 499             # mysteriously appeared in the meanwhile.
 500             os.close(os.open(self.name, self._bflags, 0600))
 501
 502         def __del__(self):
 503             self._unlink(self.name)
 504
 505     def do_create(self, pre="", suf=""):
 506         try:
 507             file = self.mktemped(self.dir, pre, suf)
 508         except:
 509             self.failOnException("mktemp")
 510
 511         self.nameCheck(file.name, self.dir, pre, suf)
 512         return file
 513
 514     def test_basic(self):
 515         # mktemp can choose usable file names
 516         self.do_create()
 517         self.do_create(pre="a")
 518         self.do_create(suf="b")
 519         self.do_create(pre="a", suf="b")
 520         self.do_create(pre="aa", suf=".txt")
 521
 522     def test_many(self):
 523         # mktemp can choose many usable file names (stochastic)
 524         extant = range(TEST_FILES)
 525         for i in extant:
 526             extant[i] = self.do_create(pre="aa")
 527
 528     def test_warning(self):
 529         # mktemp issues a warning when used
 530         warnings.filterwarnings("error",
 531                                 category=RuntimeWarning,
 532                                 message="mktemp")
 533         self.assertRaises(RuntimeWarning,
 534                           tempfile.mktemp, (), { 'dir': self.dir })
 535
 536 test_classes.append(test_mktemp)
 537
 538
 539 # We test _TemporaryFileWrapper by testing NamedTemporaryFile.
 540
 541
 542 class test_NamedTemporaryFile(TC):
 543     """Test NamedTemporaryFile()."""
 544
 545     def do_create(self, dir=None, pre="", suf=""):
 546         if dir is None:
 547             dir = tempfile.gettempdir()
 548         try:
 549             file = tempfile.NamedTemporaryFile(dir=dir, prefix=pre, suffix=suf)
 550         except:
 551             self.failOnException("NamedTemporaryFile")
 552
 553         self.nameCheck(file.name, dir, pre, suf)
 554         return file
 555
 556
 557     def test_basic(self):
 558         # NamedTemporaryFile can create files
 559         self.do_create()
 560         self.do_create(pre="a")
 561         self.do_create(suf="b")
 562         self.do_create(pre="a", suf="b")
 563         self.do_create(pre="aa", suf=".txt")
 564
 565     def test_creates_named(self):
 566         # NamedTemporaryFile creates files with names
 567         f = tempfile.NamedTemporaryFile()
 568         self.failUnless(os.path.exists(f.name),
 569                         "NamedTemporaryFile %s does not exist" % f.name)
 570
 571     def test_del_on_close(self):
 572         # A NamedTemporaryFile is deleted when closed
 573         dir = tempfile.mkdtemp()
 574         try:
 575             f = tempfile.NamedTemporaryFile(dir=dir)
 576             f.write('blat')
 577             f.close()
 578             self.failIf(os.path.exists(f.name),
 579                         "NamedTemporaryFile %s exists after close" % f.name)
 580         finally:
 581             os.rmdir(dir)
 582
 583     def test_multiple_close(self):
 584         # A NamedTemporaryFile can be closed many times without error
 585
 586         f = tempfile.NamedTemporaryFile()
 587         f.write('abc\n')
 588         f.close()
 589         try:
 590             f.close()
 591             f.close()
 592         except:
 593             self.failOnException("close")
 594
 595     # How to test the mode and bufsize parameters?
 596
 597 test_classes.append(test_NamedTemporaryFile)
 598
 599
 600 class test_TemporaryFile(TC):
 601     """Test TemporaryFile()."""
 602
 603     def test_basic(self):
 604         # TemporaryFile can create files
 605         # No point in testing the name params - the file has no name.
 606         try:
 607             tempfile.TemporaryFile()
 608         except:
 609             self.failOnException("TemporaryFile")
 610
 611     def test_has_no_name(self):
 612         # TemporaryFile creates files with no names (on this system)
 613         dir = tempfile.mkdtemp()
 614         f = tempfile.TemporaryFile(dir=dir)
 615         f.write('blat')
 616
 617         # Sneaky: because this file has no name, it should not prevent
 618         # us from removing the directory it was created in.
 619         try:
 620             os.rmdir(dir)
 621         except:
 622             ei = sys.exc_info()
 623             # cleanup
 624             f.close()
 625             os.rmdir(dir)
 626             self.failOnException("rmdir", ei)
 627
 628     def test_multiple_close(self):
 629         # A TemporaryFile can be closed many times without error
 630         f = tempfile.TemporaryFile()
 631         f.write('abc\n')
 632         f.close()
 633         try:
 634             f.close()
 635             f.close()
 636         except:
 637             self.failOnException("close")
 638
 639     # How to test the mode and bufsize parameters?
 640
 641
 642 if tempfile.NamedTemporaryFile is not tempfile.TemporaryFile:
 643     test_classes.append(test_TemporaryFile)
 644
 645 def test_main():
 646     suite = unittest.TestSuite()
 647     for c in test_classes:
 648         suite.addTest(unittest.makeSuite(c))
 649     test_support.run_suite(suite)
 650
 651 if __name__ == "__main__":
 652     test_main()