diff --git a/Lib/tempfile.py b/Lib/tempfile.py index 61462357c..927d9ca07 100644 --- a/Lib/tempfile.py +++ b/Lib/tempfile.py @@ -43,6 +43,7 @@ import os as _os import shutil as _shutil import errno as _errno from random import Random as _Random +import sys as _sys import weakref as _weakref try: @@ -74,20 +75,10 @@ template = "tmp" _once_lock = _allocate_lock() -if hasattr(_os, "lstat"): - _stat = _os.lstat -elif hasattr(_os, "stat"): - _stat = _os.stat -else: - # Fallback. All we need is something that raises OSError if the - # file doesn't exist. - def _stat(fn): - fd = _os.open(fn, _os.O_RDONLY) - _os.close(fd) def _exists(fn): try: - _stat(fn) + _os.lstat(fn) except OSError: return False else: @@ -136,7 +127,7 @@ def _sanitize_params(prefix, suffix, dir): class _RandomNameSequence: """An instance of _RandomNameSequence generates an endless sequence of unpredictable strings which can safely be incorporated - into file names. Each string is six characters long. Multiple + into file names. Each string is eight characters long. Multiple threads can safely use the same instance at the same time. _RandomNameSequence is an iterator.""" @@ -173,7 +164,9 @@ def _candidate_tempdir_list(): # Failing that, try OS-specific locations. if _os.name == 'nt': - dirlist.extend([ r'c:\temp', r'c:\tmp', r'\temp', r'\tmp' ]) + dirlist.extend([ _os.path.expanduser(r'~\AppData\Local\Temp'), + _os.path.expandvars(r'%SYSTEMROOT%\Temp'), + r'c:\temp', r'c:\tmp', r'\temp', r'\tmp' ]) else: dirlist.extend([ '/tmp', '/var/tmp', '/usr/tmp' ]) @@ -256,6 +249,7 @@ def _mkstemp_inner(dir, pre, suf, flags, output_type): for seq in range(TMP_MAX): name = next(names) file = _os.path.join(dir, pre + name + suf) + _sys.audit("tempfile.mkstemp", file) try: fd = _os.open(file, flags, 0o600) except FileExistsError: @@ -317,8 +311,7 @@ def mkstemp(suffix=None, prefix=None, dir=None, text=False): otherwise a default directory is used. If 'text' is specified and true, the file is opened in text - mode. Else (the default) the file is opened in binary mode. On - some operating systems, this makes no difference. + mode. Else (the default) the file is opened in binary mode. If any of 'suffix', 'prefix' and 'dir' are not None, they must be the same type. If they are bytes, the returned name will be bytes; str @@ -364,6 +357,7 @@ def mkdtemp(suffix=None, prefix=None, dir=None): for seq in range(TMP_MAX): name = next(names) file = _os.path.join(dir, prefix + name + suffix) + _sys.audit("tempfile.mkdtemp", file) try: _os.mkdir(file, 0o700) except FileExistsError: @@ -521,7 +515,7 @@ class _TemporaryFileWrapper: def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None, newline=None, suffix=None, prefix=None, - dir=None, delete=True): + dir=None, delete=True, *, errors=None): """Create and return a temporary file. Arguments: 'prefix', 'suffix', 'dir' -- as for mkstemp. @@ -530,6 +524,7 @@ def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None, 'encoding' -- the encoding argument to io.open (default None) 'newline' -- the newline argument to io.open (default None) 'delete' -- whether the file is deleted on close (default True). + 'errors' -- the errors argument to io.open (default None) The file is created as mkstemp() would do it. Returns an object with a file-like interface; the name of the file @@ -549,7 +544,7 @@ def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None, (fd, name) = _mkstemp_inner(dir, prefix, suffix, flags, output_type) try: file = _io.open(fd, mode, buffering=buffering, - newline=newline, encoding=encoding) + newline=newline, encoding=encoding, errors=errors) return _TemporaryFileWrapper(file, name, delete) except BaseException: @@ -557,7 +552,7 @@ def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None, _os.close(fd) raise -if _os.name != 'posix' or _os.sys.platform == 'cygwin': +if _os.name != 'posix' or _sys.platform == 'cygwin': # On non-POSIX and Cygwin systems, assume that we cannot unlink a file # while it is open. TemporaryFile = NamedTemporaryFile @@ -570,7 +565,7 @@ else: def TemporaryFile(mode='w+b', buffering=-1, encoding=None, newline=None, suffix=None, prefix=None, - dir=None): + dir=None, *, errors=None): """Create and return a temporary file. Arguments: 'prefix', 'suffix', 'dir' -- as for mkstemp. @@ -578,6 +573,7 @@ else: 'buffering' -- the buffer size argument to io.open (default -1). 'encoding' -- the encoding argument to io.open (default None) 'newline' -- the newline argument to io.open (default None) + 'errors' -- the errors argument to io.open (default None) The file is created as mkstemp() would do it. Returns an object with a file-like interface. The file has no @@ -611,7 +607,8 @@ else: else: try: return _io.open(fd, mode, buffering=buffering, - newline=newline, encoding=encoding) + newline=newline, encoding=encoding, + errors=errors) except: _os.close(fd) raise @@ -621,7 +618,7 @@ else: try: _os.unlink(name) return _io.open(fd, mode, buffering=buffering, - newline=newline, encoding=encoding) + newline=newline, encoding=encoding, errors=errors) except: _os.close(fd) raise @@ -635,20 +632,19 @@ class SpooledTemporaryFile: def __init__(self, max_size=0, mode='w+b', buffering=-1, encoding=None, newline=None, - suffix=None, prefix=None, dir=None): + suffix=None, prefix=None, dir=None, *, errors=None): if 'b' in mode: self._file = _io.BytesIO() else: - # Setting newline="\n" avoids newline translation; - # this is important because otherwise on Windows we'd - # get double newline translation upon rollover(). - self._file = _io.StringIO(newline="\n") + self._file = _io.TextIOWrapper(_io.BytesIO(), + encoding=encoding, errors=errors, + newline=newline) self._max_size = max_size self._rolled = False self._TemporaryFileArgs = {'mode': mode, 'buffering': buffering, 'suffix': suffix, 'prefix': prefix, 'encoding': encoding, 'newline': newline, - 'dir': dir} + 'dir': dir, 'errors': errors} def _check(self, file): if self._rolled: return @@ -662,8 +658,12 @@ class SpooledTemporaryFile: newfile = self._file = TemporaryFile(**self._TemporaryFileArgs) del self._TemporaryFileArgs - newfile.write(file.getvalue()) - newfile.seek(file.tell(), 0) + pos = file.tell() + if hasattr(newfile, 'buffer'): + newfile.buffer.write(file.detach().getvalue()) + else: + newfile.write(file.getvalue()) + newfile.seek(pos, 0) self._rolled = True @@ -694,12 +694,11 @@ class SpooledTemporaryFile: @property def encoding(self): - try: - return self._file.encoding - except AttributeError: - if 'b' in self._TemporaryFileArgs['mode']: - raise - return self._TemporaryFileArgs['encoding'] + return self._file.encoding + + @property + def errors(self): + return self._file.errors def fileno(self): self.rollover() @@ -727,12 +726,7 @@ class SpooledTemporaryFile: @property def newlines(self): - try: - return self._file.newlines - except AttributeError: - if 'b' in self._TemporaryFileArgs['mode']: - raise - return self._TemporaryFileArgs['newline'] + return self._file.newlines def read(self, *args): return self._file.read(*args) @@ -744,7 +738,7 @@ class SpooledTemporaryFile: return self._file.readlines(*args) def seek(self, *args): - self._file.seek(*args) + return self._file.seek(*args) @property def softspace(self): @@ -792,9 +786,39 @@ class TemporaryDirectory(object): self, self._cleanup, self.name, warn_message="Implicitly cleaning up {!r}".format(self)) + @classmethod + def _rmtree(cls, name): + def onerror(func, path, exc_info): + if issubclass(exc_info[0], PermissionError): + def resetperms(path): + try: + _os.chflags(path, 0) + except AttributeError: + pass + _os.chmod(path, 0o700) + + try: + if path != name: + resetperms(_os.path.dirname(path)) + resetperms(path) + + try: + _os.unlink(path) + # PermissionError is raised on FreeBSD for directories + except (IsADirectoryError, PermissionError): + cls._rmtree(path) + except FileNotFoundError: + pass + elif issubclass(exc_info[0], FileNotFoundError): + pass + else: + raise + + _shutil.rmtree(name, onerror=onerror) + @classmethod def _cleanup(cls, name, warn_message): - _shutil.rmtree(name) + cls._rmtree(name) _warnings.warn(warn_message, ResourceWarning) def __repr__(self): @@ -808,4 +832,4 @@ class TemporaryDirectory(object): def cleanup(self): if self._finalizer.detach(): - _shutil.rmtree(self.name) + self._rmtree(self.name) diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py index 6d3232486..bd3bdff6f 100644 --- a/Lib/test/test_os.py +++ b/Lib/test/test_os.py @@ -3783,6 +3783,7 @@ class TestScandir(unittest.TestCase): entry_lstat, os.name == 'nt') + @unittest.skipIf(sys.platform == "linux", "TODO: RUSTPYTHON, flaky test") def test_attributes(self): link = hasattr(os, 'link') symlink = support.can_symlink() diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py index 99d7f70fe..e60927157 100644 --- a/Lib/test/test_subprocess.py +++ b/Lib/test/test_subprocess.py @@ -187,10 +187,6 @@ class ProcessTestCase(BaseTestCase): stdin=tf) self.assertIn(b'PEAR', output) - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_check_output_stdin_arg = unittest.expectedFailure(test_check_output_stdin_arg) - def test_check_output_input_arg(self): # check_output() can be called with input set to a string output = subprocess.check_output( @@ -248,10 +244,6 @@ class ProcessTestCase(BaseTestCase): self.assertIn('stdin', c.exception.args[0]) self.assertIn('input', c.exception.args[0]) - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_check_output_stdin_with_input_arg = unittest.expectedFailure(test_check_output_stdin_with_input_arg) - def test_check_output_timeout(self): # check_output() function with timeout arg with self.assertRaises(subprocess.TimeoutExpired) as c: @@ -537,10 +529,6 @@ class ProcessTestCase(BaseTestCase): p.wait() self.assertEqual(p.returncode, 1) - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_stdin_filedes = unittest.expectedFailure(test_stdin_filedes) - def test_stdin_fileobj(self): # stdin is set to open file object tf = tempfile.TemporaryFile() @@ -553,10 +541,6 @@ class ProcessTestCase(BaseTestCase): p.wait() self.assertEqual(p.returncode, 1) - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_stdin_fileobj = unittest.expectedFailure(test_stdin_fileobj) - def test_stdout_pipe(self): # stdout redirection p = subprocess.Popen([sys.executable, "-c", @@ -577,10 +561,6 @@ class ProcessTestCase(BaseTestCase): os.lseek(d, 0, 0) self.assertEqual(os.read(d, 1024), b"orange") - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_stdout_filedes = unittest.expectedFailure(test_stdout_filedes) - def test_stdout_fileobj(self): # stdout is set to open file object tf = tempfile.TemporaryFile() @@ -592,10 +572,6 @@ class ProcessTestCase(BaseTestCase): tf.seek(0) self.assertEqual(tf.read(), b"orange") - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_stdout_fileobj = unittest.expectedFailure(test_stdout_fileobj) - def test_stderr_pipe(self): # stderr redirection p = subprocess.Popen([sys.executable, "-c", @@ -616,10 +592,6 @@ class ProcessTestCase(BaseTestCase): os.lseek(d, 0, 0) self.assertStderrEqual(os.read(d, 1024), b"strawberry") - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_stderr_filedes = unittest.expectedFailure(test_stderr_filedes) - def test_stderr_fileobj(self): # stderr is set to open file object tf = tempfile.TemporaryFile() @@ -631,10 +603,6 @@ class ProcessTestCase(BaseTestCase): tf.seek(0) self.assertStderrEqual(tf.read(), b"strawberry") - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_stderr_fileobj = unittest.expectedFailure(test_stderr_fileobj) - def test_stderr_redirect_with_no_stdout_redirect(self): # test stderr=STDOUT while stdout=None (not set) @@ -683,10 +651,6 @@ class ProcessTestCase(BaseTestCase): tf.seek(0) self.assertStderrEqual(tf.read(), b"appleorange") - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_stdout_stderr_file = unittest.expectedFailure(test_stdout_stderr_file) - def test_stdout_filedes_of_stdout(self): # stdout is set to 1 (#1531862). # To avoid printing the text on stdout, we do something similar to @@ -1587,10 +1551,6 @@ class RunFuncTestCase(BaseTestCase): stdin=tf, stdout=subprocess.PIPE) self.assertIn(b'PEAR', cp.stdout) - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_check_output_stdin_arg = unittest.expectedFailure(test_check_output_stdin_arg) - def test_check_output_input_arg(self): # check_output() can be called with input set to a string cp = self.run_python( @@ -1611,10 +1571,6 @@ class RunFuncTestCase(BaseTestCase): self.assertIn('stdin', c.exception.args[0]) self.assertIn('input', c.exception.args[0]) - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_check_output_stdin_with_input_arg = unittest.expectedFailure(test_check_output_stdin_with_input_arg) - def test_check_output_timeout(self): with self.assertRaises(subprocess.TimeoutExpired) as c: cp = self.run_python(( @@ -1685,10 +1641,6 @@ class RunFuncTestCase(BaseTestCase): self.assertIn('stdout', c.exception.args[0]) self.assertIn('capture_output', c.exception.args[0]) - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_stdout_with_capture_output_arg = unittest.expectedFailure(test_stdout_with_capture_output_arg) - def test_stderr_with_capture_output_arg(self): # run() refuses to accept 'stderr' with 'capture_output' tf = tempfile.TemporaryFile() @@ -1701,10 +1653,6 @@ class RunFuncTestCase(BaseTestCase): self.assertIn('stderr', c.exception.args[0]) self.assertIn('capture_output', c.exception.args[0]) - # TODO: RUSTPYTHON - if sys.platform == "win32": - test_stderr_with_capture_output_arg = unittest.expectedFailure(test_stderr_with_capture_output_arg) - # This test _might_ wind up a bit fragile on loaded build+test machines # as it depends on the timing with wide enough margins for normal situations # but does assert that it happened "soon enough" to believe the right thing diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py new file mode 100644 index 000000000..b1bfe8ec4 --- /dev/null +++ b/Lib/test/test_tempfile.py @@ -0,0 +1,1529 @@ +# tempfile.py unit tests. +import tempfile +import errno +import io +import os +import pathlib +import signal +import sys +import re +import warnings +import contextlib +import stat +import weakref +from unittest import mock + +import unittest +from test import support +from test.support import script_helper + + +has_textmode = (tempfile._text_openflags != tempfile._bin_openflags) +has_spawnl = hasattr(os, 'spawnl') + +# TEST_FILES may need to be tweaked for systems depending on the maximum +# number of files that can be opened at one time (see ulimit -n) +if sys.platform.startswith('openbsd'): + TEST_FILES = 48 +else: + TEST_FILES = 100 + +# This is organized as one test for each chunk of code in tempfile.py, +# in order of their appearance in the file. Testing which requires +# threads is not done here. + +class TestLowLevelInternals(unittest.TestCase): + def test_infer_return_type_singles(self): + self.assertIs(str, tempfile._infer_return_type('')) + self.assertIs(bytes, tempfile._infer_return_type(b'')) + self.assertIs(str, tempfile._infer_return_type(None)) + + def test_infer_return_type_multiples(self): + self.assertIs(str, tempfile._infer_return_type('', '')) + self.assertIs(bytes, tempfile._infer_return_type(b'', b'')) + with self.assertRaises(TypeError): + tempfile._infer_return_type('', b'') + with self.assertRaises(TypeError): + tempfile._infer_return_type(b'', '') + + def test_infer_return_type_multiples_and_none(self): + self.assertIs(str, tempfile._infer_return_type(None, '')) + self.assertIs(str, tempfile._infer_return_type('', None)) + self.assertIs(str, tempfile._infer_return_type(None, None)) + self.assertIs(bytes, tempfile._infer_return_type(b'', None)) + self.assertIs(bytes, tempfile._infer_return_type(None, b'')) + with self.assertRaises(TypeError): + tempfile._infer_return_type('', None, b'') + with self.assertRaises(TypeError): + tempfile._infer_return_type(b'', None, '') + + def test_infer_return_type_pathlib(self): + self.assertIs(str, tempfile._infer_return_type(pathlib.Path('/'))) + + +# Common functionality. + +class BaseTestCase(unittest.TestCase): + + str_check = re.compile(r"^[a-z0-9_-]{8}$") + b_check = re.compile(br"^[a-z0-9_-]{8}$") + + def setUp(self): + self._warnings_manager = support.check_warnings() + self._warnings_manager.__enter__() + warnings.filterwarnings("ignore", category=RuntimeWarning, + message="mktemp", module=__name__) + + def tearDown(self): + self._warnings_manager.__exit__(None, None, None) + + def nameCheck(self, name, dir, pre, suf): + (ndir, nbase) = os.path.split(name) + npre = nbase[:len(pre)] + nsuf = nbase[len(nbase)-len(suf):] + + if dir is not None: + self.assertIs( + type(name), + str + if type(dir) is str or isinstance(dir, os.PathLike) else + bytes, + "unexpected return type", + ) + if pre is not None: + self.assertIs(type(name), str if type(pre) is str else bytes, + "unexpected return type") + if suf is not None: + self.assertIs(type(name), str if type(suf) is str else bytes, + "unexpected return type") + if (dir, pre, suf) == (None, None, None): + self.assertIs(type(name), str, "default return type must be str") + + # check for equality of the absolute paths! + self.assertEqual(os.path.abspath(ndir), os.path.abspath(dir), + "file %r not in directory %r" % (name, dir)) + self.assertEqual(npre, pre, + "file %r does not begin with %r" % (nbase, pre)) + self.assertEqual(nsuf, suf, + "file %r does not end with %r" % (nbase, suf)) + + nbase = nbase[len(pre):len(nbase)-len(suf)] + check = self.str_check if isinstance(nbase, str) else self.b_check + self.assertTrue(check.match(nbase), + "random characters %r do not match %r" + % (nbase, check.pattern)) + + +class TestExports(BaseTestCase): + def test_exports(self): + # There are no surprising symbols in the tempfile module + dict = tempfile.__dict__ + + expected = { + "NamedTemporaryFile" : 1, + "TemporaryFile" : 1, + "mkstemp" : 1, + "mkdtemp" : 1, + "mktemp" : 1, + "TMP_MAX" : 1, + "gettempprefix" : 1, + "gettempprefixb" : 1, + "gettempdir" : 1, + "gettempdirb" : 1, + "tempdir" : 1, + "template" : 1, + "SpooledTemporaryFile" : 1, + "TemporaryDirectory" : 1, + } + + unexp = [] + for key in dict: + if key[0] != '_' and key not in expected: + unexp.append(key) + self.assertTrue(len(unexp) == 0, + "unexpected keys: %s" % unexp) + + +class TestRandomNameSequence(BaseTestCase): + """Test the internal iterator object _RandomNameSequence.""" + + def setUp(self): + self.r = tempfile._RandomNameSequence() + super().setUp() + + def test_get_six_char_str(self): + # _RandomNameSequence returns a six-character string + s = next(self.r) + self.nameCheck(s, '', '', '') + + def test_many(self): + # _RandomNameSequence returns no duplicate strings (stochastic) + + dict = {} + r = self.r + for i in range(TEST_FILES): + s = next(r) + self.nameCheck(s, '', '', '') + self.assertNotIn(s, dict) + dict[s] = 1 + + def supports_iter(self): + # _RandomNameSequence supports the iterator protocol + + i = 0 + r = self.r + for s in r: + i += 1 + if i == 20: + break + + @unittest.skipUnless(hasattr(os, 'fork'), + "os.fork is required for this test") + def test_process_awareness(self): + # ensure that the random source differs between + # child and parent. + read_fd, write_fd = os.pipe() + pid = None + try: + pid = os.fork() + if not pid: + # child process + os.close(read_fd) + os.write(write_fd, next(self.r).encode("ascii")) + os.close(write_fd) + # bypass the normal exit handlers- leave those to + # the parent. + os._exit(0) + + # parent process + parent_value = next(self.r) + child_value = os.read(read_fd, len(parent_value)).decode("ascii") + finally: + if pid: + # best effort to ensure the process can't bleed out + # via any bugs above + try: + os.kill(pid, signal.SIGKILL) + except OSError: + pass + + # Read the process exit status to avoid zombie process + os.waitpid(pid, 0) + + os.close(read_fd) + os.close(write_fd) + self.assertNotEqual(child_value, parent_value) + + + +class TestCandidateTempdirList(BaseTestCase): + """Test the internal function _candidate_tempdir_list.""" + + def test_nonempty_list(self): + # _candidate_tempdir_list returns a nonempty list of strings + + cand = tempfile._candidate_tempdir_list() + + self.assertFalse(len(cand) == 0) + for c in cand: + self.assertIsInstance(c, str) + + def test_wanted_dirs(self): + # _candidate_tempdir_list contains the expected directories + + # Make sure the interesting environment variables are all set. + with support.EnvironmentVarGuard() as env: + for envname in 'TMPDIR', 'TEMP', 'TMP': + dirname = os.getenv(envname) + if not dirname: + env[envname] = os.path.abspath(envname) + + cand = tempfile._candidate_tempdir_list() + + for envname in 'TMPDIR', 'TEMP', 'TMP': + dirname = os.getenv(envname) + if not dirname: raise ValueError + self.assertIn(dirname, cand) + + try: + dirname = os.getcwd() + except (AttributeError, OSError): + dirname = os.curdir + + self.assertIn(dirname, cand) + + # Not practical to try to verify the presence of OS-specific + # paths in this list. + + +# We test _get_default_tempdir some more by testing gettempdir. + +class TestGetDefaultTempdir(BaseTestCase): + """Test _get_default_tempdir().""" + + def test_no_files_left_behind(self): + # use a private empty directory + with tempfile.TemporaryDirectory() as our_temp_directory: + # force _get_default_tempdir() to consider our empty directory + def our_candidate_list(): + return [our_temp_directory] + + with support.swap_attr(tempfile, "_candidate_tempdir_list", + our_candidate_list): + # verify our directory is empty after _get_default_tempdir() + tempfile._get_default_tempdir() + self.assertEqual(os.listdir(our_temp_directory), []) + + def raise_OSError(*args, **kwargs): + raise OSError() + + with support.swap_attr(io, "open", raise_OSError): + # test again with failing io.open() + with self.assertRaises(FileNotFoundError): + tempfile._get_default_tempdir() + self.assertEqual(os.listdir(our_temp_directory), []) + + def bad_writer(*args, **kwargs): + fp = orig_open(*args, **kwargs) + fp.write = raise_OSError + return fp + + with support.swap_attr(io, "open", bad_writer) as orig_open: + # test again with failing write() + with self.assertRaises(FileNotFoundError): + tempfile._get_default_tempdir() + self.assertEqual(os.listdir(our_temp_directory), []) + + +class TestGetCandidateNames(BaseTestCase): + """Test the internal function _get_candidate_names.""" + + def test_retval(self): + # _get_candidate_names returns a _RandomNameSequence object + obj = tempfile._get_candidate_names() + self.assertIsInstance(obj, tempfile._RandomNameSequence) + + def test_same_thing(self): + # _get_candidate_names always returns the same object + a = tempfile._get_candidate_names() + b = tempfile._get_candidate_names() + + self.assertTrue(a is b) + + +@contextlib.contextmanager +def _inside_empty_temp_dir(): + dir = tempfile.mkdtemp() + try: + with support.swap_attr(tempfile, 'tempdir', dir): + yield + finally: + support.rmtree(dir) + + +def _mock_candidate_names(*names): + return support.swap_attr(tempfile, + '_get_candidate_names', + lambda: iter(names)) + + +class TestBadTempdir: + + def test_read_only_directory(self): + with _inside_empty_temp_dir(): + oldmode = mode = os.stat(tempfile.tempdir).st_mode + mode &= ~(stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH) + os.chmod(tempfile.tempdir, mode) + try: + if os.access(tempfile.tempdir, os.W_OK): + self.skipTest("can't set the directory read-only") + with self.assertRaises(PermissionError): + self.make_temp() + self.assertEqual(os.listdir(tempfile.tempdir), []) + finally: + os.chmod(tempfile.tempdir, oldmode) + + def test_nonexisting_directory(self): + with _inside_empty_temp_dir(): + tempdir = os.path.join(tempfile.tempdir, 'nonexistent') + with support.swap_attr(tempfile, 'tempdir', tempdir): + with self.assertRaises(FileNotFoundError): + self.make_temp() + + def test_non_directory(self): + with _inside_empty_temp_dir(): + tempdir = os.path.join(tempfile.tempdir, 'file') + open(tempdir, 'wb').close() + with support.swap_attr(tempfile, 'tempdir', tempdir): + with self.assertRaises((NotADirectoryError, FileNotFoundError)): + self.make_temp() + + # TODO: RUSTPYTHON + if sys.platform != "win32": + test_non_directory = unittest.expectedFailure(test_non_directory) + + +class TestMkstempInner(TestBadTempdir, BaseTestCase): + """Test the internal function _mkstemp_inner.""" + + class mkstemped: + _bflags = tempfile._bin_openflags + _tflags = tempfile._text_openflags + _close = os.close + _unlink = os.unlink + + def __init__(self, dir, pre, suf, bin): + if bin: flags = self._bflags + else: flags = self._tflags + + output_type = tempfile._infer_return_type(dir, pre, suf) + (self.fd, self.name) = tempfile._mkstemp_inner(dir, pre, suf, flags, output_type) + + def write(self, str): + os.write(self.fd, str) + + def __del__(self): + self._close(self.fd) + self._unlink(self.name) + + def do_create(self, dir=None, pre=None, suf=None, bin=1): + output_type = tempfile._infer_return_type(dir, pre, suf) + if dir is None: + if output_type is str: + dir = tempfile.gettempdir() + else: + dir = tempfile.gettempdirb() + if pre is None: + pre = output_type() + if suf is None: + suf = output_type() + file = self.mkstemped(dir, pre, suf, bin) + + self.nameCheck(file.name, dir, pre, suf) + return file + + def test_basic(self): + # _mkstemp_inner can create files + self.do_create().write(b"blat") + self.do_create(pre="a").write(b"blat") + self.do_create(suf="b").write(b"blat") + self.do_create(pre="a", suf="b").write(b"blat") + self.do_create(pre="aa", suf=".txt").write(b"blat") + + def test_basic_with_bytes_names(self): + # _mkstemp_inner can create files when given name parts all + # specified as bytes. + dir_b = tempfile.gettempdirb() + self.do_create(dir=dir_b, suf=b"").write(b"blat") + self.do_create(dir=dir_b, pre=b"a").write(b"blat") + self.do_create(dir=dir_b, suf=b"b").write(b"blat") + self.do_create(dir=dir_b, pre=b"a", suf=b"b").write(b"blat") + self.do_create(dir=dir_b, pre=b"aa", suf=b".txt").write(b"blat") + # Can't mix str & binary types in the args. + with self.assertRaises(TypeError): + self.do_create(dir="", suf=b"").write(b"blat") + with self.assertRaises(TypeError): + self.do_create(dir=dir_b, pre="").write(b"blat") + with self.assertRaises(TypeError): + self.do_create(dir=dir_b, pre=b"", suf="").write(b"blat") + + def test_basic_many(self): + # _mkstemp_inner can create many files (stochastic) + extant = list(range(TEST_FILES)) + for i in extant: + extant[i] = self.do_create(pre="aa") + + def test_choose_directory(self): + # _mkstemp_inner can create files in a user-selected directory + dir = tempfile.mkdtemp() + try: + self.do_create(dir=dir).write(b"blat") + self.do_create(dir=pathlib.Path(dir)).write(b"blat") + finally: + os.rmdir(dir) + + def test_file_mode(self): + # _mkstemp_inner creates files with the proper mode + + file = self.do_create() + mode = stat.S_IMODE(os.stat(file.name).st_mode) + expected = 0o600 + if sys.platform == 'win32': + # There's no distinction among 'user', 'group' and 'world'; + # replicate the 'user' bits. + user = expected >> 6 + expected = user * (1 + 8 + 64) + self.assertEqual(mode, expected) + + @unittest.skipUnless(has_spawnl, 'os.spawnl not available') + def test_noinherit(self): + # _mkstemp_inner file handles are not inherited by child processes + + if support.verbose: + v="v" + else: + v="q" + + file = self.do_create() + self.assertEqual(os.get_inheritable(file.fd), False) + fd = "%d" % file.fd + + try: + me = __file__ + except NameError: + me = sys.argv[0] + + # We have to exec something, so that FD_CLOEXEC will take + # effect. The core of this test is therefore in + # tf_inherit_check.py, which see. + tester = os.path.join(os.path.dirname(os.path.abspath(me)), + "tf_inherit_check.py") + + # On Windows a spawn* /path/ with embedded spaces shouldn't be quoted, + # but an arg with embedded spaces should be decorated with double + # quotes on each end + if sys.platform == 'win32': + decorated = '"%s"' % sys.executable + tester = '"%s"' % tester + else: + decorated = sys.executable + + retval = os.spawnl(os.P_WAIT, sys.executable, decorated, tester, v, fd) + self.assertFalse(retval < 0, + "child process caught fatal signal %d" % -retval) + self.assertFalse(retval > 0, "child process reports failure %d"%retval) + + @unittest.skipUnless(has_textmode, "text mode not available") + def test_textmode(self): + # _mkstemp_inner can create files in text mode + + # A text file is truncated at the first Ctrl+Z byte + f = self.do_create(bin=0) + f.write(b"blat\x1a") + f.write(b"extra\n") + os.lseek(f.fd, 0, os.SEEK_SET) + self.assertEqual(os.read(f.fd, 20), b"blat") + + def make_temp(self): + return tempfile._mkstemp_inner(tempfile.gettempdir(), + tempfile.gettempprefix(), + '', + tempfile._bin_openflags, + str) + + def test_collision_with_existing_file(self): + # _mkstemp_inner tries another name when a file with + # the chosen name already exists + with _inside_empty_temp_dir(), \ + _mock_candidate_names('aaa', 'aaa', 'bbb'): + (fd1, name1) = self.make_temp() + os.close(fd1) + self.assertTrue(name1.endswith('aaa')) + + (fd2, name2) = self.make_temp() + os.close(fd2) + self.assertTrue(name2.endswith('bbb')) + + def test_collision_with_existing_directory(self): + # _mkstemp_inner tries another name when a directory with + # the chosen name already exists + with _inside_empty_temp_dir(), \ + _mock_candidate_names('aaa', 'aaa', 'bbb'): + dir = tempfile.mkdtemp() + self.assertTrue(dir.endswith('aaa')) + + (fd, name) = self.make_temp() + os.close(fd) + self.assertTrue(name.endswith('bbb')) + + +class TestGetTempPrefix(BaseTestCase): + """Test gettempprefix().""" + + def test_sane_template(self): + # gettempprefix returns a nonempty prefix string + p = tempfile.gettempprefix() + + self.assertIsInstance(p, str) + self.assertGreater(len(p), 0) + + pb = tempfile.gettempprefixb() + + self.assertIsInstance(pb, bytes) + self.assertGreater(len(pb), 0) + + def test_usable_template(self): + # gettempprefix returns a usable prefix string + + # Create a temp directory, avoiding use of the prefix. + # Then attempt to create a file whose name is + # prefix + 'xxxxxx.xxx' in that directory. + p = tempfile.gettempprefix() + "xxxxxx.xxx" + d = tempfile.mkdtemp(prefix="") + try: + p = os.path.join(d, p) + fd = os.open(p, os.O_RDWR | os.O_CREAT) + os.close(fd) + os.unlink(p) + finally: + os.rmdir(d) + + +class TestGetTempDir(BaseTestCase): + """Test gettempdir().""" + + def test_directory_exists(self): + # gettempdir returns a directory which exists + + for d in (tempfile.gettempdir(), tempfile.gettempdirb()): + self.assertTrue(os.path.isabs(d) or d == os.curdir, + "%r is not an absolute path" % d) + self.assertTrue(os.path.isdir(d), + "%r is not a directory" % d) + + def test_directory_writable(self): + # gettempdir returns a directory writable by the user + + # sneaky: just instantiate a NamedTemporaryFile, which + # defaults to writing into the directory returned by + # gettempdir. + with tempfile.NamedTemporaryFile() as file: + file.write(b"blat") + + def test_same_thing(self): + # gettempdir always returns the same object + a = tempfile.gettempdir() + b = tempfile.gettempdir() + c = tempfile.gettempdirb() + + self.assertTrue(a is b) + self.assertNotEqual(type(a), type(c)) + self.assertEqual(a, os.fsdecode(c)) + + def test_case_sensitive(self): + # gettempdir should not flatten its case + # even on a case-insensitive file system + case_sensitive_tempdir = tempfile.mkdtemp("-Temp") + _tempdir, tempfile.tempdir = tempfile.tempdir, None + try: + with support.EnvironmentVarGuard() as env: + # Fake the first env var which is checked as a candidate + env["TMPDIR"] = case_sensitive_tempdir + self.assertEqual(tempfile.gettempdir(), case_sensitive_tempdir) + finally: + tempfile.tempdir = _tempdir + support.rmdir(case_sensitive_tempdir) + + +class TestMkstemp(BaseTestCase): + """Test mkstemp().""" + + def do_create(self, dir=None, pre=None, suf=None): + output_type = tempfile._infer_return_type(dir, pre, suf) + if dir is None: + if output_type is str: + dir = tempfile.gettempdir() + else: + dir = tempfile.gettempdirb() + if pre is None: + pre = output_type() + if suf is None: + suf = output_type() + (fd, name) = tempfile.mkstemp(dir=dir, prefix=pre, suffix=suf) + (ndir, nbase) = os.path.split(name) + adir = os.path.abspath(dir) + self.assertEqual(adir, ndir, + "Directory '%s' incorrectly returned as '%s'" % (adir, ndir)) + + try: + self.nameCheck(name, dir, pre, suf) + finally: + os.close(fd) + os.unlink(name) + + def test_basic(self): + # mkstemp can create files + self.do_create() + self.do_create(pre="a") + self.do_create(suf="b") + self.do_create(pre="a", suf="b") + self.do_create(pre="aa", suf=".txt") + self.do_create(dir=".") + + def test_basic_with_bytes_names(self): + # mkstemp can create files when given name parts all + # specified as bytes. + d = tempfile.gettempdirb() + self.do_create(dir=d, suf=b"") + self.do_create(dir=d, pre=b"a") + self.do_create(dir=d, suf=b"b") + self.do_create(dir=d, pre=b"a", suf=b"b") + self.do_create(dir=d, pre=b"aa", suf=b".txt") + self.do_create(dir=b".") + with self.assertRaises(TypeError): + self.do_create(dir=".", pre=b"aa", suf=b".txt") + with self.assertRaises(TypeError): + self.do_create(dir=b".", pre="aa", suf=b".txt") + with self.assertRaises(TypeError): + self.do_create(dir=b".", pre=b"aa", suf=".txt") + + + def test_choose_directory(self): + # mkstemp can create directories in a user-selected directory + dir = tempfile.mkdtemp() + try: + self.do_create(dir=dir) + self.do_create(dir=pathlib.Path(dir)) + finally: + os.rmdir(dir) + + +class TestMkdtemp(TestBadTempdir, BaseTestCase): + """Test mkdtemp().""" + + def make_temp(self): + return tempfile.mkdtemp() + + def do_create(self, dir=None, pre=None, suf=None): + output_type = tempfile._infer_return_type(dir, pre, suf) + if dir is None: + if output_type is str: + dir = tempfile.gettempdir() + else: + dir = tempfile.gettempdirb() + if pre is None: + pre = output_type() + if suf is None: + suf = output_type() + name = tempfile.mkdtemp(dir=dir, prefix=pre, suffix=suf) + + try: + self.nameCheck(name, dir, pre, suf) + return name + except: + os.rmdir(name) + raise + + def test_basic(self): + # mkdtemp can create directories + os.rmdir(self.do_create()) + os.rmdir(self.do_create(pre="a")) + os.rmdir(self.do_create(suf="b")) + os.rmdir(self.do_create(pre="a", suf="b")) + os.rmdir(self.do_create(pre="aa", suf=".txt")) + + def test_basic_with_bytes_names(self): + # mkdtemp can create directories when given all binary parts + d = tempfile.gettempdirb() + os.rmdir(self.do_create(dir=d)) + os.rmdir(self.do_create(dir=d, pre=b"a")) + os.rmdir(self.do_create(dir=d, suf=b"b")) + os.rmdir(self.do_create(dir=d, pre=b"a", suf=b"b")) + os.rmdir(self.do_create(dir=d, pre=b"aa", suf=b".txt")) + with self.assertRaises(TypeError): + os.rmdir(self.do_create(dir=d, pre="aa", suf=b".txt")) + with self.assertRaises(TypeError): + os.rmdir(self.do_create(dir=d, pre=b"aa", suf=".txt")) + with self.assertRaises(TypeError): + os.rmdir(self.do_create(dir="", pre=b"aa", suf=b".txt")) + + def test_basic_many(self): + # mkdtemp can create many directories (stochastic) + extant = list(range(TEST_FILES)) + try: + for i in extant: + extant[i] = self.do_create(pre="aa") + finally: + for i in extant: + if(isinstance(i, str)): + os.rmdir(i) + + def test_choose_directory(self): + # mkdtemp can create directories in a user-selected directory + dir = tempfile.mkdtemp() + try: + os.rmdir(self.do_create(dir=dir)) + os.rmdir(self.do_create(dir=pathlib.Path(dir))) + finally: + os.rmdir(dir) + + def test_mode(self): + # mkdtemp creates directories with the proper mode + + dir = self.do_create() + try: + mode = stat.S_IMODE(os.stat(dir).st_mode) + mode &= 0o777 # Mask off sticky bits inherited from /tmp + expected = 0o700 + if sys.platform == 'win32': + # There's no distinction among 'user', 'group' and 'world'; + # replicate the 'user' bits. + user = expected >> 6 + expected = user * (1 + 8 + 64) + self.assertEqual(mode, expected) + finally: + os.rmdir(dir) + + def test_collision_with_existing_file(self): + # mkdtemp tries another name when a file with + # the chosen name already exists + with _inside_empty_temp_dir(), \ + _mock_candidate_names('aaa', 'aaa', 'bbb'): + file = tempfile.NamedTemporaryFile(delete=False) + file.close() + self.assertTrue(file.name.endswith('aaa')) + dir = tempfile.mkdtemp() + self.assertTrue(dir.endswith('bbb')) + + def test_collision_with_existing_directory(self): + # mkdtemp tries another name when a directory with + # the chosen name already exists + with _inside_empty_temp_dir(), \ + _mock_candidate_names('aaa', 'aaa', 'bbb'): + dir1 = tempfile.mkdtemp() + self.assertTrue(dir1.endswith('aaa')) + dir2 = tempfile.mkdtemp() + self.assertTrue(dir2.endswith('bbb')) + + +class TestMktemp(BaseTestCase): + """Test mktemp().""" + + # For safety, all use of mktemp must occur in a private directory. + # We must also suppress the RuntimeWarning it generates. + def setUp(self): + self.dir = tempfile.mkdtemp() + super().setUp() + + def tearDown(self): + if self.dir: + os.rmdir(self.dir) + self.dir = None + super().tearDown() + + class mktemped: + _unlink = os.unlink + _bflags = tempfile._bin_openflags + + def __init__(self, dir, pre, suf): + self.name = tempfile.mktemp(dir=dir, prefix=pre, suffix=suf) + # Create the file. This will raise an exception if it's + # mysteriously appeared in the meanwhile. + os.close(os.open(self.name, self._bflags, 0o600)) + + def __del__(self): + self._unlink(self.name) + + def do_create(self, pre="", suf=""): + file = self.mktemped(self.dir, pre, suf) + + self.nameCheck(file.name, self.dir, pre, suf) + return file + + def test_basic(self): + # mktemp can choose usable file names + self.do_create() + self.do_create(pre="a") + self.do_create(suf="b") + self.do_create(pre="a", suf="b") + self.do_create(pre="aa", suf=".txt") + + def test_many(self): + # mktemp can choose many usable file names (stochastic) + extant = list(range(TEST_FILES)) + for i in extant: + extant[i] = self.do_create(pre="aa") + +## def test_warning(self): +## # mktemp issues a warning when used +## warnings.filterwarnings("error", +## category=RuntimeWarning, +## message="mktemp") +## self.assertRaises(RuntimeWarning, +## tempfile.mktemp, dir=self.dir) + + +# We test _TemporaryFileWrapper by testing NamedTemporaryFile. + + +class TestNamedTemporaryFile(BaseTestCase): + """Test NamedTemporaryFile().""" + + def do_create(self, dir=None, pre="", suf="", delete=True): + if dir is None: + dir = tempfile.gettempdir() + file = tempfile.NamedTemporaryFile(dir=dir, prefix=pre, suffix=suf, + delete=delete) + + self.nameCheck(file.name, dir, pre, suf) + return file + + + def test_basic(self): + # NamedTemporaryFile can create files + self.do_create() + self.do_create(pre="a") + self.do_create(suf="b") + self.do_create(pre="a", suf="b") + self.do_create(pre="aa", suf=".txt") + + def test_method_lookup(self): + # Issue #18879: Looking up a temporary file method should keep it + # alive long enough. + f = self.do_create() + wr = weakref.ref(f) + write = f.write + write2 = f.write + del f + write(b'foo') + del write + write2(b'bar') + del write2 + if support.check_impl_detail(cpython=True): + # No reference cycle was created. + self.assertIsNone(wr()) + + def test_iter(self): + # Issue #23700: getting iterator from a temporary file should keep + # it alive as long as it's being iterated over + lines = [b'spam\n', b'eggs\n', b'beans\n'] + def make_file(): + f = tempfile.NamedTemporaryFile(mode='w+b') + f.write(b''.join(lines)) + f.seek(0) + return f + for i, l in enumerate(make_file()): + self.assertEqual(l, lines[i]) + self.assertEqual(i, len(lines) - 1) + + def test_creates_named(self): + # NamedTemporaryFile creates files with names + f = tempfile.NamedTemporaryFile() + self.assertTrue(os.path.exists(f.name), + "NamedTemporaryFile %s does not exist" % f.name) + + def test_del_on_close(self): + # A NamedTemporaryFile is deleted when closed + dir = tempfile.mkdtemp() + try: + with tempfile.NamedTemporaryFile(dir=dir) as f: + f.write(b'blat') + self.assertFalse(os.path.exists(f.name), + "NamedTemporaryFile %s exists after close" % f.name) + finally: + os.rmdir(dir) + + def test_dis_del_on_close(self): + # Tests that delete-on-close can be disabled + dir = tempfile.mkdtemp() + tmp = None + try: + f = tempfile.NamedTemporaryFile(dir=dir, delete=False) + tmp = f.name + f.write(b'blat') + f.close() + self.assertTrue(os.path.exists(f.name), + "NamedTemporaryFile %s missing after close" % f.name) + finally: + if tmp is not None: + os.unlink(tmp) + os.rmdir(dir) + + def test_multiple_close(self): + # A NamedTemporaryFile can be closed many times without error + f = tempfile.NamedTemporaryFile() + f.write(b'abc\n') + f.close() + f.close() + f.close() + + def test_context_manager(self): + # A NamedTemporaryFile can be used as a context manager + with tempfile.NamedTemporaryFile() as f: + self.assertTrue(os.path.exists(f.name)) + self.assertFalse(os.path.exists(f.name)) + def use_closed(): + with f: + pass + self.assertRaises(ValueError, use_closed) + + def test_no_leak_fd(self): + # Issue #21058: don't leak file descriptor when io.open() fails + closed = [] + os_close = os.close + def close(fd): + closed.append(fd) + os_close(fd) + + with mock.patch('os.close', side_effect=close): + with mock.patch('io.open', side_effect=ValueError): + self.assertRaises(ValueError, tempfile.NamedTemporaryFile) + self.assertEqual(len(closed), 1) + + def test_bad_mode(self): + dir = tempfile.mkdtemp() + self.addCleanup(support.rmtree, dir) + with self.assertRaises(ValueError): + tempfile.NamedTemporaryFile(mode='wr', dir=dir) + with self.assertRaises(TypeError): + tempfile.NamedTemporaryFile(mode=2, dir=dir) + self.assertEqual(os.listdir(dir), []) + + # How to test the mode and bufsize parameters? + +class TestSpooledTemporaryFile(BaseTestCase): + """Test SpooledTemporaryFile().""" + + def do_create(self, max_size=0, dir=None, pre="", suf=""): + if dir is None: + dir = tempfile.gettempdir() + file = tempfile.SpooledTemporaryFile(max_size=max_size, dir=dir, prefix=pre, suffix=suf) + + return file + + + def test_basic(self): + # SpooledTemporaryFile can create files + f = self.do_create() + self.assertFalse(f._rolled) + f = self.do_create(max_size=100, pre="a", suf=".txt") + self.assertFalse(f._rolled) + + def test_del_on_close(self): + # A SpooledTemporaryFile is deleted when closed + dir = tempfile.mkdtemp() + try: + f = tempfile.SpooledTemporaryFile(max_size=10, dir=dir) + self.assertFalse(f._rolled) + f.write(b'blat ' * 5) + self.assertTrue(f._rolled) + filename = f.name + f.close() + self.assertFalse(isinstance(filename, str) and os.path.exists(filename), + "SpooledTemporaryFile %s exists after close" % filename) + finally: + os.rmdir(dir) + + def test_rewrite_small(self): + # A SpooledTemporaryFile can be written to multiple within the max_size + f = self.do_create(max_size=30) + self.assertFalse(f._rolled) + for i in range(5): + f.seek(0, 0) + f.write(b'x' * 20) + self.assertFalse(f._rolled) + + def test_write_sequential(self): + # A SpooledTemporaryFile should hold exactly max_size bytes, and roll + # over afterward + f = self.do_create(max_size=30) + self.assertFalse(f._rolled) + f.write(b'x' * 20) + self.assertFalse(f._rolled) + f.write(b'x' * 10) + self.assertFalse(f._rolled) + f.write(b'x') + self.assertTrue(f._rolled) + + def test_writelines(self): + # Verify writelines with a SpooledTemporaryFile + f = self.do_create() + f.writelines((b'x', b'y', b'z')) + pos = f.seek(0) + self.assertEqual(pos, 0) + buf = f.read() + self.assertEqual(buf, b'xyz') + + def test_writelines_sequential(self): + # A SpooledTemporaryFile should hold exactly max_size bytes, and roll + # over afterward + f = self.do_create(max_size=35) + f.writelines((b'x' * 20, b'x' * 10, b'x' * 5)) + self.assertFalse(f._rolled) + f.write(b'x') + self.assertTrue(f._rolled) + + def test_sparse(self): + # A SpooledTemporaryFile that is written late in the file will extend + # when that occurs + f = self.do_create(max_size=30) + self.assertFalse(f._rolled) + pos = f.seek(100, 0) + self.assertEqual(pos, 100) + self.assertFalse(f._rolled) + f.write(b'x') + self.assertTrue(f._rolled) + + def test_fileno(self): + # A SpooledTemporaryFile should roll over to a real file on fileno() + f = self.do_create(max_size=30) + self.assertFalse(f._rolled) + self.assertTrue(f.fileno() > 0) + self.assertTrue(f._rolled) + + def test_multiple_close_before_rollover(self): + # A SpooledTemporaryFile can be closed many times without error + f = tempfile.SpooledTemporaryFile() + f.write(b'abc\n') + self.assertFalse(f._rolled) + f.close() + f.close() + f.close() + + def test_multiple_close_after_rollover(self): + # A SpooledTemporaryFile can be closed many times without error + f = tempfile.SpooledTemporaryFile(max_size=1) + f.write(b'abc\n') + self.assertTrue(f._rolled) + f.close() + f.close() + f.close() + + def test_bound_methods(self): + # It should be OK to steal a bound method from a SpooledTemporaryFile + # and use it independently; when the file rolls over, those bound + # methods should continue to function + f = self.do_create(max_size=30) + read = f.read + write = f.write + seek = f.seek + + write(b"a" * 35) + write(b"b" * 35) + seek(0, 0) + self.assertEqual(read(70), b'a'*35 + b'b'*35) + + def test_properties(self): + f = tempfile.SpooledTemporaryFile(max_size=10) + f.write(b'x' * 10) + self.assertFalse(f._rolled) + self.assertEqual(f.mode, 'w+b') + self.assertIsNone(f.name) + with self.assertRaises(AttributeError): + f.newlines + with self.assertRaises(AttributeError): + f.encoding + with self.assertRaises(AttributeError): + f.errors + + f.write(b'x') + self.assertTrue(f._rolled) + self.assertEqual(f.mode, 'rb+') + self.assertIsNotNone(f.name) + with self.assertRaises(AttributeError): + f.newlines + with self.assertRaises(AttributeError): + f.encoding + with self.assertRaises(AttributeError): + f.errors + + # TODO: RUSTPYTHON + @unittest.expectedFailure + def test_text_mode(self): + # Creating a SpooledTemporaryFile with a text mode should produce + # a file object reading and writing (Unicode) text strings. + f = tempfile.SpooledTemporaryFile(mode='w+', max_size=10, + encoding="utf-8") + f.write("abc\n") + f.seek(0) + self.assertEqual(f.read(), "abc\n") + f.write("def\n") + f.seek(0) + self.assertEqual(f.read(), "abc\ndef\n") + self.assertFalse(f._rolled) + self.assertEqual(f.mode, 'w+') + self.assertIsNone(f.name) + self.assertEqual(f.newlines, os.linesep) + self.assertEqual(f.encoding, "utf-8") + self.assertEqual(f.errors, "strict") + + f.write("xyzzy\n") + f.seek(0) + self.assertEqual(f.read(), "abc\ndef\nxyzzy\n") + # Check that Ctrl+Z doesn't truncate the file + f.write("foo\x1abar\n") + f.seek(0) + self.assertEqual(f.read(), "abc\ndef\nxyzzy\nfoo\x1abar\n") + self.assertTrue(f._rolled) + self.assertEqual(f.mode, 'w+') + self.assertIsNotNone(f.name) + self.assertEqual(f.newlines, os.linesep) + self.assertEqual(f.encoding, "utf-8") + self.assertEqual(f.errors, "strict") + + # TODO: RUSTPYTHON + @unittest.expectedFailure + def test_text_newline_and_encoding(self): + f = tempfile.SpooledTemporaryFile(mode='w+', max_size=10, + newline='', encoding='utf-8', + errors='ignore') + f.write("\u039B\r\n") + f.seek(0) + self.assertEqual(f.read(), "\u039B\r\n") + self.assertFalse(f._rolled) + self.assertEqual(f.mode, 'w+') + self.assertIsNone(f.name) + self.assertIsNotNone(f.newlines) + self.assertEqual(f.encoding, "utf-8") + self.assertEqual(f.errors, "ignore") + + f.write("\u039C" * 10 + "\r\n") + f.write("\u039D" * 20) + f.seek(0) + self.assertEqual(f.read(), + "\u039B\r\n" + ("\u039C" * 10) + "\r\n" + ("\u039D" * 20)) + self.assertTrue(f._rolled) + self.assertEqual(f.mode, 'w+') + self.assertIsNotNone(f.name) + self.assertIsNotNone(f.newlines) + self.assertEqual(f.encoding, 'utf-8') + self.assertEqual(f.errors, 'ignore') + + def test_context_manager_before_rollover(self): + # A SpooledTemporaryFile can be used as a context manager + with tempfile.SpooledTemporaryFile(max_size=1) as f: + self.assertFalse(f._rolled) + self.assertFalse(f.closed) + self.assertTrue(f.closed) + def use_closed(): + with f: + pass + self.assertRaises(ValueError, use_closed) + + def test_context_manager_during_rollover(self): + # A SpooledTemporaryFile can be used as a context manager + with tempfile.SpooledTemporaryFile(max_size=1) as f: + self.assertFalse(f._rolled) + f.write(b'abc\n') + f.flush() + self.assertTrue(f._rolled) + self.assertFalse(f.closed) + self.assertTrue(f.closed) + def use_closed(): + with f: + pass + self.assertRaises(ValueError, use_closed) + + def test_context_manager_after_rollover(self): + # A SpooledTemporaryFile can be used as a context manager + f = tempfile.SpooledTemporaryFile(max_size=1) + f.write(b'abc\n') + f.flush() + self.assertTrue(f._rolled) + with f: + self.assertFalse(f.closed) + self.assertTrue(f.closed) + def use_closed(): + with f: + pass + self.assertRaises(ValueError, use_closed) + + def test_truncate_with_size_parameter(self): + # A SpooledTemporaryFile can be truncated to zero size + f = tempfile.SpooledTemporaryFile(max_size=10) + f.write(b'abcdefg\n') + f.seek(0) + f.truncate() + self.assertFalse(f._rolled) + self.assertEqual(f._file.getvalue(), b'') + # A SpooledTemporaryFile can be truncated to a specific size + f = tempfile.SpooledTemporaryFile(max_size=10) + f.write(b'abcdefg\n') + f.truncate(4) + self.assertFalse(f._rolled) + self.assertEqual(f._file.getvalue(), b'abcd') + # A SpooledTemporaryFile rolls over if truncated to large size + f = tempfile.SpooledTemporaryFile(max_size=10) + f.write(b'abcdefg\n') + f.truncate(20) + self.assertTrue(f._rolled) + self.assertEqual(os.fstat(f.fileno()).st_size, 20) + + +if tempfile.NamedTemporaryFile is not tempfile.TemporaryFile: + + class TestTemporaryFile(BaseTestCase): + """Test TemporaryFile().""" + + def test_basic(self): + # TemporaryFile can create files + # No point in testing the name params - the file has no name. + tempfile.TemporaryFile() + + def test_has_no_name(self): + # TemporaryFile creates files with no names (on this system) + dir = tempfile.mkdtemp() + f = tempfile.TemporaryFile(dir=dir) + f.write(b'blat') + + # Sneaky: because this file has no name, it should not prevent + # us from removing the directory it was created in. + try: + os.rmdir(dir) + except: + # cleanup + f.close() + os.rmdir(dir) + raise + + def test_multiple_close(self): + # A TemporaryFile can be closed many times without error + f = tempfile.TemporaryFile() + f.write(b'abc\n') + f.close() + f.close() + f.close() + + # How to test the mode and bufsize parameters? + def test_mode_and_encoding(self): + + def roundtrip(input, *args, **kwargs): + with tempfile.TemporaryFile(*args, **kwargs) as fileobj: + fileobj.write(input) + fileobj.seek(0) + self.assertEqual(input, fileobj.read()) + + roundtrip(b"1234", "w+b") + roundtrip("abdc\n", "w+") + roundtrip("\u039B", "w+", encoding="utf-16") + roundtrip("foo\r\n", "w+", newline="") + + def test_no_leak_fd(self): + # Issue #21058: don't leak file descriptor when io.open() fails + closed = [] + os_close = os.close + def close(fd): + closed.append(fd) + os_close(fd) + + with mock.patch('os.close', side_effect=close): + with mock.patch('io.open', side_effect=ValueError): + self.assertRaises(ValueError, tempfile.TemporaryFile) + self.assertEqual(len(closed), 1) + + + +# Helper for test_del_on_shutdown +class NulledModules: + def __init__(self, *modules): + self.refs = [mod.__dict__ for mod in modules] + self.contents = [ref.copy() for ref in self.refs] + + def __enter__(self): + for d in self.refs: + for key in d: + d[key] = None + + def __exit__(self, *exc_info): + for d, c in zip(self.refs, self.contents): + d.clear() + d.update(c) + +class TestTemporaryDirectory(BaseTestCase): + """Test TemporaryDirectory().""" + + def do_create(self, dir=None, pre="", suf="", recurse=1, dirs=1, files=1): + if dir is None: + dir = tempfile.gettempdir() + tmp = tempfile.TemporaryDirectory(dir=dir, prefix=pre, suffix=suf) + self.nameCheck(tmp.name, dir, pre, suf) + self.do_create2(tmp.name, recurse, dirs, files) + return tmp + + def do_create2(self, path, recurse=1, dirs=1, files=1): + # Create subdirectories and some files + if recurse: + for i in range(dirs): + name = os.path.join(path, "dir%d" % i) + os.mkdir(name) + self.do_create2(name, recurse-1, dirs, files) + for i in range(files): + with open(os.path.join(path, "test%d.txt" % i), "wb") as f: + f.write(b"Hello world!") + + def test_mkdtemp_failure(self): + # Check no additional exception if mkdtemp fails + # Previously would raise AttributeError instead + # (noted as part of Issue #10188) + with tempfile.TemporaryDirectory() as nonexistent: + pass + with self.assertRaises(FileNotFoundError) as cm: + tempfile.TemporaryDirectory(dir=nonexistent) + self.assertEqual(cm.exception.errno, errno.ENOENT) + + # TODO: RUSTPYTHON + if sys.platform == "win32": + test_mkdtemp_failure = unittest.expectedFailure(test_mkdtemp_failure) + + def test_explicit_cleanup(self): + # A TemporaryDirectory is deleted when cleaned up + dir = tempfile.mkdtemp() + try: + d = self.do_create(dir=dir) + self.assertTrue(os.path.exists(d.name), + "TemporaryDirectory %s does not exist" % d.name) + d.cleanup() + self.assertFalse(os.path.exists(d.name), + "TemporaryDirectory %s exists after cleanup" % d.name) + finally: + os.rmdir(dir) + + @support.skip_unless_symlink + def test_cleanup_with_symlink_to_a_directory(self): + # cleanup() should not follow symlinks to directories (issue #12464) + d1 = self.do_create() + d2 = self.do_create(recurse=0) + + # Symlink d1/foo -> d2 + os.symlink(d2.name, os.path.join(d1.name, "foo")) + + # This call to cleanup() should not follow the "foo" symlink + d1.cleanup() + + self.assertFalse(os.path.exists(d1.name), + "TemporaryDirectory %s exists after cleanup" % d1.name) + self.assertTrue(os.path.exists(d2.name), + "Directory pointed to by a symlink was deleted") + self.assertEqual(os.listdir(d2.name), ['test0.txt'], + "Contents of the directory pointed to by a symlink " + "were deleted") + d2.cleanup() + + @support.cpython_only + def test_del_on_collection(self): + # A TemporaryDirectory is deleted when garbage collected + dir = tempfile.mkdtemp() + try: + d = self.do_create(dir=dir) + name = d.name + del d # Rely on refcounting to invoke __del__ + self.assertFalse(os.path.exists(name), + "TemporaryDirectory %s exists after __del__" % name) + finally: + os.rmdir(dir) + + # TODO: RUSTPYTHON + @unittest.expectedFailure + def test_del_on_shutdown(self): + # A TemporaryDirectory may be cleaned up during shutdown + with self.do_create() as dir: + for mod in ('builtins', 'os', 'shutil', 'sys', 'tempfile', 'warnings'): + code = """if True: + import builtins + import os + import shutil + import sys + import tempfile + import warnings + + tmp = tempfile.TemporaryDirectory(dir={dir!r}) + sys.stdout.buffer.write(tmp.name.encode()) + + tmp2 = os.path.join(tmp.name, 'test_dir') + os.mkdir(tmp2) + with open(os.path.join(tmp2, "test0.txt"), "w") as f: + f.write("Hello world!") + + {mod}.tmp = tmp + + warnings.filterwarnings("always", category=ResourceWarning) + """.format(dir=dir, mod=mod) + rc, out, err = script_helper.assert_python_ok("-c", code) + tmp_name = out.decode().strip() + self.assertFalse(os.path.exists(tmp_name), + "TemporaryDirectory %s exists after cleanup" % tmp_name) + err = err.decode('utf-8', 'backslashreplace') + self.assertNotIn("Exception ", err) + self.assertIn("ResourceWarning: Implicitly cleaning up", err) + + # TODO: RUSTPYTHON + @unittest.expectedFailure + def test_exit_on_shutdown(self): + # Issue #22427 + with self.do_create() as dir: + code = """if True: + import sys + import tempfile + import warnings + + def generator(): + with tempfile.TemporaryDirectory(dir={dir!r}) as tmp: + yield tmp + g = generator() + sys.stdout.buffer.write(next(g).encode()) + + warnings.filterwarnings("always", category=ResourceWarning) + """.format(dir=dir) + rc, out, err = script_helper.assert_python_ok("-c", code) + tmp_name = out.decode().strip() + self.assertFalse(os.path.exists(tmp_name), + "TemporaryDirectory %s exists after cleanup" % tmp_name) + err = err.decode('utf-8', 'backslashreplace') + self.assertNotIn("Exception ", err) + self.assertIn("ResourceWarning: Implicitly cleaning up", err) + + # TODO: RUSTPYTHON + @unittest.expectedFailure + def test_warnings_on_cleanup(self): + # ResourceWarning will be triggered by __del__ + with self.do_create() as dir: + d = self.do_create(dir=dir, recurse=3) + name = d.name + + # Check for the resource warning + with support.check_warnings(('Implicitly', ResourceWarning), quiet=False): + warnings.filterwarnings("always", category=ResourceWarning) + del d + support.gc_collect() + self.assertFalse(os.path.exists(name), + "TemporaryDirectory %s exists after __del__" % name) + + def test_multiple_close(self): + # Can be cleaned-up many times without error + d = self.do_create() + d.cleanup() + d.cleanup() + d.cleanup() + + def test_context_manager(self): + # Can be used as a context manager + d = self.do_create() + with d as name: + self.assertTrue(os.path.exists(name)) + self.assertEqual(name, d.name) + self.assertFalse(os.path.exists(name)) + + def test_modes(self): + for mode in range(8): + mode <<= 6 + with self.subTest(mode=format(mode, '03o')): + d = self.do_create(recurse=3, dirs=2, files=2) + with d: + # Change files and directories mode recursively. + for root, dirs, files in os.walk(d.name, topdown=False): + for name in files: + os.chmod(os.path.join(root, name), mode) + os.chmod(root, mode) + d.cleanup() + self.assertFalse(os.path.exists(d.name)) + + # TODO: RUSTPYTHON + if sys.platform not in {"darwin", "win32"}: + test_modes = unittest.expectedFailure(test_modes) + + @unittest.skipUnless(hasattr(os, 'chflags'), 'requires os.lchflags') + def test_flags(self): + flags = stat.UF_IMMUTABLE | stat.UF_NOUNLINK + d = self.do_create(recurse=3, dirs=2, files=2) + with d: + # Change files and directories flags recursively. + for root, dirs, files in os.walk(d.name, topdown=False): + for name in files: + os.chflags(os.path.join(root, name), flags) + os.chflags(root, flags) + d.cleanup() + self.assertFalse(os.path.exists(d.name)) + + +if __name__ == "__main__": + unittest.main() diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs index 8ee485659..06f460fe9 100644 --- a/vm/src/stdlib/os.rs +++ b/vm/src/stdlib/os.rs @@ -2871,6 +2871,10 @@ mod nt { #[pyattr] use libc::O_BINARY; + #[pyattr] + // use libc::O_TEMPORARY; + const O_TEMPORARY: i32 = 0x40; + #[pyfunction] pub(super) fn access(path: PyPathLike, mode: u8, vm: &VirtualMachine) -> PyResult { use winapi::um::{fileapi, winnt};