Lib/test/test_shutil.py

   1 # Copyright (C) 2003 Python Software Foundation
   2
   3 import unittest
   4 import shutil
   5 import tempfile
   6 import sys
   7 import stat
   8 import os
   9 import os.path
  10 from test import test_support
  11 from test.test_support import TESTFN
  12
  13 class TestShutil(unittest.TestCase):
  14     def test_rmtree_errors(self):
  15         # filename is guaranteed not to exist
  16         filename = tempfile.mktemp()
  17         self.assertRaises(OSError, shutil.rmtree, filename)
  18
  19     # See bug #1071513 for why we don't run this on cygwin
  20     # and bug #1076467 for why we don't run this as root.
  21     if (hasattr(os, 'chmod') and sys.platform[:6] != 'cygwin'
  22         and not (hasattr(os, 'geteuid') and os.geteuid() == 0)):
  23         def test_on_error(self):
  24             self.errorState = 0
  25             os.mkdir(TESTFN)
  26             self.childpath = os.path.join(TESTFN, 'a')
  27             f = open(self.childpath, 'w')
  28             f.close()
  29             old_dir_mode = os.stat(TESTFN).st_mode
  30             old_child_mode = os.stat(self.childpath).st_mode
  31             # Make unwritable.
  32             os.chmod(self.childpath, stat.S_IREAD)
  33             os.chmod(TESTFN, stat.S_IREAD)
  34
  35             shutil.rmtree(TESTFN, onerror=self.check_args_to_onerror)
  36             # Test whether onerror has actually been called.
  37             self.assertEqual(self.errorState, 2,
  38                              "Expected call to onerror function did not happen.")
  39
  40             # Make writable again.
  41             os.chmod(TESTFN, old_dir_mode)
  42             os.chmod(self.childpath, old_child_mode)
  43
  44             # Clean up.
  45             shutil.rmtree(TESTFN)
  46
  47     def check_args_to_onerror(self, func, arg, exc):
  48         if self.errorState == 0:
  49             self.assertEqual(func, os.remove)
  50             self.assertEqual(arg, self.childpath)
  51             self.failUnless(issubclass(exc[0], OSError))
  52             self.errorState = 1
  53         else:
  54             self.assertEqual(func, os.rmdir)
  55             self.assertEqual(arg, TESTFN)
  56             self.failUnless(issubclass(exc[0], OSError))
  57             self.errorState = 2
  58
  59     def test_rmtree_dont_delete_file(self):
  60         # When called on a file instead of a directory, don't delete it.
  61         handle, path = tempfile.mkstemp()
  62         os.fdopen(handle).close()
  63         self.assertRaises(OSError, shutil.rmtree, path)
  64         os.remove(path)
  65
  66     def test_copytree_simple(self):
  67         def write_data(path, data):
  68             f = open(path, "w")
  69             f.write(data)
  70             f.close()
  71
  72         def read_data(path):
  73             f = open(path)
  74             data = f.read()
  75             f.close()
  76             return data
  77
  78         src_dir = tempfile.mkdtemp()
  79         dst_dir = os.path.join(tempfile.mkdtemp(), 'destination')
  80
  81         write_data(os.path.join(src_dir, 'test.txt'), '123')
  82
  83         os.mkdir(os.path.join(src_dir, 'test_dir'))
  84         write_data(os.path.join(src_dir, 'test_dir', 'test.txt'), '456')
  85
  86         try:
  87             shutil.copytree(src_dir, dst_dir)
  88             self.assertTrue(os.path.isfile(os.path.join(dst_dir, 'test.txt')))
  89             self.assertTrue(os.path.isdir(os.path.join(dst_dir, 'test_dir')))
  90             self.assertTrue(os.path.isfile(os.path.join(dst_dir, 'test_dir',
  91                                                         'test.txt')))
  92             actual = read_data(os.path.join(dst_dir, 'test.txt'))
  93             self.assertEqual(actual, '123')
  94             actual = read_data(os.path.join(dst_dir, 'test_dir', 'test.txt'))
  95             self.assertEqual(actual, '456')
  96         finally:
  97             for path in (
  98                     os.path.join(src_dir, 'test.txt'),
  99                     os.path.join(dst_dir, 'test.txt'),
 100                     os.path.join(src_dir, 'test_dir', 'test.txt'),
 101                     os.path.join(dst_dir, 'test_dir', 'test.txt'),
 102                 ):
 103                 if os.path.exists(path):
 104                     os.remove(path)
 105             for path in (src_dir,
 106                     os.path.abspath(os.path.join(dst_dir, os.path.pardir))
 107                 ):
 108                 if os.path.exists(path):
 109                     shutil.rmtree(path)
 110
 111     def test_copytree_with_exclude(self):
 112
 113         def write_data(path, data):
 114             f = open(path, "w")
 115             f.write(data)
 116             f.close()
 117
 118         def read_data(path):
 119             f = open(path)
 120             data = f.read()
 121             f.close()
 122             return data
 123
 124         # creating data
 125         join = os.path.join
 126         exists = os.path.exists
 127         src_dir = tempfile.mkdtemp()
 128         dst_dir = join(tempfile.mkdtemp(), 'destination')
 129         write_data(join(src_dir, 'test.txt'), '123')
 130         write_data(join(src_dir, 'test.tmp'), '123')
 131         os.mkdir(join(src_dir, 'test_dir'))
 132         write_data(join(src_dir, 'test_dir', 'test.txt'), '456')
 133         os.mkdir(join(src_dir, 'test_dir2'))
 134         write_data(join(src_dir, 'test_dir2', 'test.txt'), '456')
 135         os.mkdir(join(src_dir, 'test_dir2', 'subdir'))
 136         os.mkdir(join(src_dir, 'test_dir2', 'subdir2'))
 137         write_data(join(src_dir, 'test_dir2', 'subdir', 'test.txt'), '456')
 138         write_data(join(src_dir, 'test_dir2', 'subdir2', 'test.py'), '456')
 139
 140
 141         # testing glob-like patterns
 142         try:
 143             patterns = shutil.ignore_patterns('*.tmp', 'test_dir2')
 144             shutil.copytree(src_dir, dst_dir, ignore=patterns)
 145             # checking the result: some elements should not be copied
 146             self.assert_(exists(join(dst_dir, 'test.txt')))
 147             self.assert_(not exists(join(dst_dir, 'test.tmp')))
 148             self.assert_(not exists(join(dst_dir, 'test_dir2')))
 149         finally:
 150             if os.path.exists(dst_dir):
 151                 shutil.rmtree(dst_dir)
 152         try:
 153             patterns = shutil.ignore_patterns('*.tmp', 'subdir*')
 154             shutil.copytree(src_dir, dst_dir, ignore=patterns)
 155             # checking the result: some elements should not be copied
 156             self.assert_(not exists(join(dst_dir, 'test.tmp')))
 157             self.assert_(not exists(join(dst_dir, 'test_dir2', 'subdir2')))
 158             self.assert_(not exists(join(dst_dir, 'test_dir2', 'subdir')))
 159         finally:
 160             if os.path.exists(dst_dir):
 161                 shutil.rmtree(dst_dir)
 162
 163         # testing callable-style
 164         try:
 165             def _filter(src, names):
 166                 res = []
 167                 for name in names:
 168                     path = os.path.join(src, name)
 169
 170                     if (os.path.isdir(path) and
 171                         path.split()[-1] == 'subdir'):
 172                         res.append(name)
 173                     elif os.path.splitext(path)[-1] in ('.py'):
 174                         res.append(name)
 175                 return res
 176
 177             shutil.copytree(src_dir, dst_dir, ignore=_filter)
 178
 179             # checking the result: some elements should not be copied
 180             self.assert_(not exists(join(dst_dir, 'test_dir2', 'subdir2',
 181                                     'test.py')))
 182             self.assert_(not exists(join(dst_dir, 'test_dir2', 'subdir')))
 183
 184         finally:
 185             if os.path.exists(dst_dir):
 186                 shutil.rmtree(dst_dir)
 187
 188     if hasattr(os, "symlink"):
 189         def test_dont_copy_file_onto_link_to_itself(self):
 190             # bug 851123.
 191             os.mkdir(TESTFN)
 192             src = os.path.join(TESTFN, 'cheese')
 193             dst = os.path.join(TESTFN, 'shop')
 194             try:
 195                 f = open(src, 'w')
 196                 f.write('cheddar')
 197                 f.close()
 198
 199                 os.link(src, dst)
 200                 self.assertRaises(shutil.Error, shutil.copyfile, src, dst)
 201                 self.assertEqual(open(src,'r').read(), 'cheddar')
 202                 os.remove(dst)
 203
 204                 # Using `src` here would mean we end up with a symlink pointing
 205                 # to TESTFN/TESTFN/cheese, while it should point at
 206                 # TESTFN/cheese.
 207                 os.symlink('cheese', dst)
 208                 self.assertRaises(shutil.Error, shutil.copyfile, src, dst)
 209                 self.assertEqual(open(src,'r').read(), 'cheddar')
 210                 os.remove(dst)
 211             finally:
 212                 try:
 213                     shutil.rmtree(TESTFN)
 214                 except OSError:
 215                     pass
 216
 217         def test_rmtree_on_symlink(self):
 218             # bug 1669.
 219             os.mkdir(TESTFN)
 220             try:
 221                 src = os.path.join(TESTFN, 'cheese')
 222                 dst = os.path.join(TESTFN, 'shop')
 223                 os.mkdir(src)
 224                 os.symlink(src, dst)
 225                 self.assertRaises(OSError, shutil.rmtree, dst)
 226             finally:
 227                 shutil.rmtree(TESTFN, ignore_errors=True)
 228
 229
 230 class TestMove(unittest.TestCase):
 231
 232     def setUp(self):
 233         filename = "foo"
 234         self.src_dir = tempfile.mkdtemp()
 235         self.dst_dir = tempfile.mkdtemp()
 236         self.src_file = os.path.join(self.src_dir, filename)
 237         self.dst_file = os.path.join(self.dst_dir, filename)
 238         # Try to create a dir in the current directory, hoping that it is
 239         # not located on the same filesystem as the system tmp dir.
 240         try:
 241             self.dir_other_fs = tempfile.mkdtemp(
 242                 dir=os.path.dirname(__file__))
 243             self.file_other_fs = os.path.join(self.dir_other_fs,
 244                 filename)
 245         except OSError:
 246             self.dir_other_fs = None
 247         with open(self.src_file, "wb") as f:
 248             f.write("spam")
 249
 250     def tearDown(self):
 251         for d in (self.src_dir, self.dst_dir, self.dir_other_fs):
 252             try:
 253                 if d:
 254                     shutil.rmtree(d)
 255             except:
 256                 pass
 257
 258     def _check_move_file(self, src, dst, real_dst):
 259         contents = open(src, "rb").read()
 260         shutil.move(src, dst)
 261         self.assertEqual(contents, open(real_dst, "rb").read())
 262         self.assertFalse(os.path.exists(src))
 263
 264     def _check_move_dir(self, src, dst, real_dst):
 265         contents = sorted(os.listdir(src))
 266         shutil.move(src, dst)
 267         self.assertEqual(contents, sorted(os.listdir(real_dst)))
 268         self.assertFalse(os.path.exists(src))
 269
 270     def test_move_file(self):
 271         # Move a file to another location on the same filesystem.
 272         self._check_move_file(self.src_file, self.dst_file, self.dst_file)
 273
 274     def test_move_file_to_dir(self):
 275         # Move a file inside an existing dir on the same filesystem.
 276         self._check_move_file(self.src_file, self.dst_dir, self.dst_file)
 277
 278     def test_move_file_other_fs(self):
 279         # Move a file to an existing dir on another filesystem.
 280         if not self.dir_other_fs:
 281             # skip
 282             return
 283         self._check_move_file(self.src_file, self.file_other_fs,
 284             self.file_other_fs)
 285
 286     def test_move_file_to_dir_other_fs(self):
 287         # Move a file to another location on another filesystem.
 288         if not self.dir_other_fs:
 289             # skip
 290             return
 291         self._check_move_file(self.src_file, self.dir_other_fs,
 292             self.file_other_fs)
 293
 294     def test_move_dir(self):
 295         # Move a dir to another location on the same filesystem.
 296         dst_dir = tempfile.mktemp()
 297         try:
 298             self._check_move_dir(self.src_dir, dst_dir, dst_dir)
 299         finally:
 300             try:
 301                 shutil.rmtree(dst_dir)
 302             except:
 303                 pass
 304
 305     def test_move_dir_other_fs(self):
 306         # Move a dir to another location on another filesystem.
 307         if not self.dir_other_fs:
 308             # skip
 309             return
 310         dst_dir = tempfile.mktemp(dir=self.dir_other_fs)
 311         try:
 312             self._check_move_dir(self.src_dir, dst_dir, dst_dir)
 313         finally:
 314             try:
 315                 shutil.rmtree(dst_dir)
 316             except:
 317                 pass
 318
 319     def test_move_dir_to_dir(self):
 320         # Move a dir inside an existing dir on the same filesystem.
 321         self._check_move_dir(self.src_dir, self.dst_dir,
 322             os.path.join(self.dst_dir, os.path.basename(self.src_dir)))
 323
 324     def test_move_dir_to_dir_other_fs(self):
 325         # Move a dir inside an existing dir on another filesystem.
 326         if not self.dir_other_fs:
 327             # skip
 328             return
 329         self._check_move_dir(self.src_dir, self.dir_other_fs,
 330             os.path.join(self.dir_other_fs, os.path.basename(self.src_dir)))
 331
 332     def test_existing_file_inside_dest_dir(self):
 333         # A file with the same name inside the destination dir already exists.
 334         with open(self.dst_file, "wb"):
 335             pass
 336         self.assertRaises(shutil.Error, shutil.move, self.src_file, self.dst_dir)
 337
 338     def test_dont_move_dir_in_itself(self):
 339         # Moving a dir inside itself raises an Error.
 340         dst = os.path.join(self.src_dir, "bar")
 341         self.assertRaises(shutil.Error, shutil.move, self.src_dir, dst)
 342
 343
 344
 345 def test_main():
 346     test_support.run_unittest(TestShutil, TestMove)
 347
 348 if __name__ == '__main__':
 349     test_main()