followlinks/follow_symlinks/symlinks flags unification.

Lib/test/test_shutil.py

 # Copyright (C) 2003 Python Software Foundation
 
 import unittest
 import shutil
 import tempfile
 import sys
 import stat
 import os
 import os.path
 import errno
@@ skipping 98 matching lines @@
         return d
 
     def test_rmtree_works_on_bytes(self):
         tmp = self.mkdtemp()
         victim = os.path.join(tmp, 'killme')
         os.mkdir(victim)
         write_file(os.path.join(victim, 'somefile'), 'foo')
         victim = os.fsencode(victim)
         self.assertIsInstance(victim, bytes)
         shutil.rmtree(victim)
+
+    @support.skip_unless_symlink
+    def test_rmtree_fails_on_symlink(self):
+        tmp = self.mkdtemp()
+        dir_ = os.path.join(tmp, 'dir')
+        os.mkdir(dir_)
+        link = os.path.join(tmp, 'link')
+        os.symlink(dir_, link)
+        self.assertRaises(OSError, shutil.rmtree, link)
+        self.assertTrue(os.path.exists(dir_))
+
+    @support.skip_unless_symlink
+    def test_rmtree_works_on_symlinks(self):
+        tmp = self.mkdtemp()
+        dir1 = os.path.join(tmp, 'dir1')
+        dir2 = os.path.join(dir1, 'dir2')
+        dir3 = os.path.join(tmp, 'dir3')
+        for d in dir1, dir2, dir3:
+            os.mkdir(d)
+        file1 = os.path.join(tmp, 'file1')
+        write_file(file1, 'foo')
+        link1 = os.path.join(dir1, 'link1')
+        os.symlink(dir2, link1)
+        link2 = os.path.join(dir1, 'link2')
+        os.symlink(dir3, link2)
+        link3 = os.path.join(dir1, 'link3')
+        os.symlink(file1, link3)
+        # make sure symlinks are removed but not followed
+        shutil.rmtree(dir1)
+        self.assertFalse(os.path.exists(dir1))
+        self.assertTrue(os.path.exists(dir3))
+        self.assertTrue(os.path.exists(file1))
 
     def test_rmtree_errors(self):
         # filename is guaranteed not to exist
         filename = tempfile.mktemp()
         self.assertRaises(OSError, shutil.rmtree, filename)
 
     # See bug #1071513 for why we don't run this on cygwin
     # and bug #1076467 for why we don't run this as root.
     if (hasattr(os, 'chmod') and sys.platform[:6] != 'cygwin'
         and not (hasattr(os, 'geteuid') and os.geteuid() == 0)):
@@ skipping 48 matching lines @@
             self.errorState += 1
         else:
             self.assertEqual(func, os.rmdir)
             self.assertEqual(arg, TESTFN)
             self.assertTrue(issubclass(exc[0], OSError))
             self.errorState = 3
 
     def test_rmtree_does_not_choke_on_failing_lstat(self):
         try:
             orig_lstat = os.lstat
-            def raiser(fn):
+            def raiser(fn, *args, **kwargs):
                 if fn != TESTFN:
                     raise OSError()
                 else:
                     return orig_lstat(fn)
             os.lstat = raiser
 
             os.mkdir(TESTFN)
             write_file((TESTFN, 'foo'), 'foo')
             shutil.rmtree(TESTFN)
         finally:
@@ skipping 287 matching lines @@
         os.symlink(src, link)
         # don't follow
         shutil.copyfile(link, dst_link, follow_symlinks=False)
         self.assertTrue(os.path.islink(dst_link))
         self.assertEqual(os.readlink(link), os.readlink(dst_link))
         # follow
         shutil.copyfile(link, dst)
         self.assertFalse(os.path.islink(dst))
 
     def test_rmtree_uses_safe_fd_version_if_available(self):
-        if os.unlink in os.supports_dir_fd and os.open in os.supports_dir_fd:
+        _use_fd_functions = ({os.open, os.stat, os.unlink, os.rmdir} <=
+                             os.supports_dir_fd and
+                             os.listdir in os.supports_fd and
+                             os.stat in os.supports_follow_symlinks)
+        if _use_fd_functions:
             self.assertTrue(shutil._use_fd_functions)
             self.assertTrue(shutil.rmtree.avoids_symlink_attacks)
             tmp_dir = self.mkdtemp()
             d = os.path.join(tmp_dir, 'a')
             os.mkdir(d)
             try:
                 real_rmtree = shutil._rmtree_safe_fd
                 class Called(Exception): pass
                 def _raiser(*args, **kwargs):
                     raise Called
@@ skipping 26 matching lines @@
         self.assertTrue(os.path.isdir(os.path.join(dst_dir, 'test_dir')))
         self.assertTrue(os.path.isfile(os.path.join(dst_dir, 'test_dir',
                                                     'test.txt')))
         actual = read_file((dst_dir, 'test.txt'))
         self.assertEqual(actual, '123')
         actual = read_file((dst_dir, 'test_dir', 'test.txt'))
         self.assertEqual(actual, '456')
 
     @support.skip_unless_symlink
     def test_copytree_symlinks(self):
-        tmp_dir = self.mkdtemp()
-        src_dir = os.path.join(tmp_dir, 'src')
-        dst_dir = os.path.join(tmp_dir, 'dst')
-        sub_dir = os.path.join(src_dir, 'sub')
-        os.mkdir(src_dir)
-        os.mkdir(sub_dir)
-        write_file((src_dir, 'file.txt'), 'foo')
-        src_link = os.path.join(sub_dir, 'link')
-        dst_link = os.path.join(dst_dir, 'sub/link')
-        os.symlink(os.path.join(src_dir, 'file.txt'),
-                   src_link)
-        if hasattr(os, 'lchmod'):
-            os.lchmod(src_link, stat.S_IRWXU | stat.S_IRWXO)
-        if hasattr(os, 'lchflags') and hasattr(stat, 'UF_NODUMP'):
-            os.lchflags(src_link, stat.UF_NODUMP)
-        src_stat = os.lstat(src_link)
-        shutil.copytree(src_dir, dst_dir, follow_symlinks=False)
-        self.assertTrue(os.path.islink(os.path.join(dst_dir, 'sub', 'link')))
-        self.assertEqual(os.readlink(os.path.join(dst_dir, 'sub', 'link')),
-                         os.path.join(src_dir, 'file.txt'))
-        dst_stat = os.lstat(dst_link)
-        if hasattr(os, 'lchmod'):
-            self.assertEqual(dst_stat.st_mode, src_stat.st_mode)
-        if hasattr(os, 'lchflags'):
-            self.assertEqual(dst_stat.st_flags, src_stat.st_flags)
-
-    def test_copytree_symlinks_old(self):
         tmp_dir = self.mkdtemp()
         src_dir = os.path.join(tmp_dir, 'src')
         dst_dir = os.path.join(tmp_dir, 'dst')
         sub_dir = os.path.join(src_dir, 'sub')
         os.mkdir(src_dir)
         os.mkdir(sub_dir)
         write_file((src_dir, 'file.txt'), 'foo')
         src_link = os.path.join(sub_dir, 'link')
         dst_link = os.path.join(dst_dir, 'sub/link')
         os.symlink(os.path.join(src_dir, 'file.txt'),
                    src_link)
         if hasattr(os, 'lchmod'):
             os.lchmod(src_link, stat.S_IRWXU | stat.S_IRWXO)
         if hasattr(os, 'lchflags') and hasattr(stat, 'UF_NODUMP'):
             os.lchflags(src_link, stat.UF_NODUMP)
         src_stat = os.lstat(src_link)
         shutil.copytree(src_dir, dst_dir, symlinks=True)
         self.assertTrue(os.path.islink(os.path.join(dst_dir, 'sub', 'link')))
         self.assertEqual(os.readlink(os.path.join(dst_dir, 'sub', 'link')),
                          os.path.join(src_dir, 'file.txt'))
         dst_stat = os.lstat(dst_link)
         if hasattr(os, 'lchmod'):
             self.assertEqual(dst_stat.st_mode, src_stat.st_mode)
         if hasattr(os, 'lchflags'):
             self.assertEqual(dst_stat.st_flags, src_stat.st_flags)
 
-    def test_copytree_incompatible_args(self):
-        tmp_dir = self.mkdtemp()
-        src_dir = os.path.join(tmp_dir, 'src')
-        dst_dir = os.path.join(tmp_dir, 'dst')
-        sub_dir = os.path.join(src_dir, 'sub')
-        os.mkdir(src_dir)
-        os.mkdir(sub_dir)
-        self.assertRaises(TypeError, shutil.copytree, src_dir, dst_dir, symlinks=True, follow_symlinks=False)
-
     def test_copytree_with_exclude(self):
         # creating data
         join = os.path.join
         exists = os.path.exists
         src_dir = tempfile.mkdtemp()
         try:
             dst_dir = join(tempfile.mkdtemp(), 'destination')
             write_file((src_dir, 'test.txt'), '123')
             write_file((src_dir, 'test.tmp'), '123')
             os.mkdir(join(src_dir, 'test_dir'))
@@ skipping 163 matching lines @@
         os.symlink('IDONTEXIST', os.path.join(src_dir, 'test.txt'))
         os.mkdir(os.path.join(src_dir, 'test_dir'))
         write_file((src_dir, 'test_dir', 'test.txt'), '456')
         self.assertRaises(Error, shutil.copytree, src_dir, dst_dir)
 
         # a dangling symlink is ignored with the proper flag
         dst_dir = os.path.join(self.mkdtemp(), 'destination2')
         shutil.copytree(src_dir, dst_dir, ignore_dangling_symlinks=True)
         self.assertNotIn('test.txt', os.listdir(dst_dir))
 
-        # a dangling symlink is copied if follow_symlinks=False
+        # a dangling symlink is copied if symlinks=True
         dst_dir = os.path.join(self.mkdtemp(), 'destination3')
-        shutil.copytree(src_dir, dst_dir, follow_symlinks=False)
+        shutil.copytree(src_dir, dst_dir, symlinks=True)
         self.assertIn('test.txt', os.listdir(dst_dir))
 
     def _copy_file(self, method):
         fname = 'test.txt'
         tmpdir = self.mkdtemp()
         write_file((tmpdir, fname), 'xxx')
         file1 = os.path.join(tmpdir, fname)
         tmpdir2 = self.mkdtemp()
         method(file1, tmpdir2)
         file2 = os.path.join(tmpdir2, fname)
@@ skipping 801 matching lines @@
 
         self.assertEqual(expected, actual)
 
 
 def test_main():
     support.run_unittest(TestShutil, TestMove, TestCopyFile,
                          TermsizeTests, TestWhich)
 
 if __name__ == '__main__':
     test_main()