Lib/distutils/tests/test_archive_util.py

   1 """Tests for distutils.archive_util."""
   2 __revision__ = "$Id: test_archive_util.py 86637 2010-11-21 13:34:58Z ezio.melotti $"
   3
   4 import unittest
   5 import os
   6 import tarfile
   7 from os.path import splitdrive
   8 import warnings
   9
  10 from distutils.archive_util import (check_archive_formats, make_tarball,
  11                                     make_zipfile, make_archive,
  12                                     ARCHIVE_FORMATS)
  13 from distutils.spawn import find_executable, spawn
  14 from distutils.tests import support
  15 from test.test_support import check_warnings
  16
  17 try:
  18     import grp
  19     import pwd
  20     UID_GID_SUPPORT = True
  21 except ImportError:
  22     UID_GID_SUPPORT = False
  23
  24 try:
  25     import zipfile
  26     ZIP_SUPPORT = True
  27 except ImportError:
  28     ZIP_SUPPORT = find_executable('zip')
  29
  30 # some tests will fail if zlib is not available
  31 try:
  32     import zlib
  33 except ImportError:
  34     zlib = None
  35
  36
  37 class ArchiveUtilTestCase(support.TempdirManager,
  38                           support.LoggingSilencer,
  39                           unittest.TestCase):
  40
  41     @unittest.skipUnless(zlib, "requires zlib")
  42     def test_make_tarball(self):
  43         # creating something to tar
  44         tmpdir = self.mkdtemp()
  45         self.write_file([tmpdir, 'file1'], 'xxx')
  46         self.write_file([tmpdir, 'file2'], 'xxx')
  47         os.mkdir(os.path.join(tmpdir, 'sub'))
  48         self.write_file([tmpdir, 'sub', 'file3'], 'xxx')
  49
  50         tmpdir2 = self.mkdtemp()
  51         unittest.skipUnless(splitdrive(tmpdir)[0] == splitdrive(tmpdir2)[0],
  52                             "source and target should be on same drive")
  53
  54         base_name = os.path.join(tmpdir2, 'archive')
  55
  56         # working with relative paths to avoid tar warnings
  57         old_dir = os.getcwd()
  58         os.chdir(tmpdir)
  59         try:
  60             make_tarball(splitdrive(base_name)[1], '.')
  61         finally:
  62             os.chdir(old_dir)
  63
  64         # check if the compressed tarball was created
  65         tarball = base_name + '.tar.gz'
  66         self.assertTrue(os.path.exists(tarball))
  67
  68         # trying an uncompressed one
  69         base_name = os.path.join(tmpdir2, 'archive')
  70         old_dir = os.getcwd()
  71         os.chdir(tmpdir)
  72         try:
  73             make_tarball(splitdrive(base_name)[1], '.', compress=None)
  74         finally:
  75             os.chdir(old_dir)
  76         tarball = base_name + '.tar'
  77         self.assertTrue(os.path.exists(tarball))
  78
  79     def _tarinfo(self, path):
  80         tar = tarfile.open(path)
  81         try:
  82             names = tar.getnames()
  83             names.sort()
  84             return tuple(names)
  85         finally:
  86             tar.close()
  87
  88     def _create_files(self):
  89         # creating something to tar
  90         tmpdir = self.mkdtemp()
  91         dist = os.path.join(tmpdir, 'dist')
  92         os.mkdir(dist)
  93         self.write_file([dist, 'file1'], 'xxx')
  94         self.write_file([dist, 'file2'], 'xxx')
  95         os.mkdir(os.path.join(dist, 'sub'))
  96         self.write_file([dist, 'sub', 'file3'], 'xxx')
  97         os.mkdir(os.path.join(dist, 'sub2'))
  98         tmpdir2 = self.mkdtemp()
  99         base_name = os.path.join(tmpdir2, 'archive')
 100         return tmpdir, tmpdir2, base_name
 101
 102     @unittest.skipUnless(zlib, "Requires zlib")
 103     @unittest.skipUnless(find_executable('tar') and find_executable('gzip'),
 104                          'Need the tar command to run')
 105     def test_tarfile_vs_tar(self):
 106         tmpdir, tmpdir2, base_name =  self._create_files()
 107         old_dir = os.getcwd()
 108         os.chdir(tmpdir)
 109         try:
 110             make_tarball(base_name, 'dist')
 111         finally:
 112             os.chdir(old_dir)
 113
 114         # check if the compressed tarball was created
 115         tarball = base_name + '.tar.gz'
 116         self.assertTrue(os.path.exists(tarball))
 117
 118         # now create another tarball using `tar`
 119         tarball2 = os.path.join(tmpdir, 'archive2.tar.gz')
 120         tar_cmd = ['tar', '-cf', 'archive2.tar', 'dist']
 121         gzip_cmd = ['gzip', '-f9', 'archive2.tar']
 122         old_dir = os.getcwd()
 123         os.chdir(tmpdir)
 124         try:
 125             spawn(tar_cmd)
 126             spawn(gzip_cmd)
 127         finally:
 128             os.chdir(old_dir)
 129
 130         self.assertTrue(os.path.exists(tarball2))
 131         # let's compare both tarballs
 132         self.assertEqual(self._tarinfo(tarball), self._tarinfo(tarball2))
 133
 134         # trying an uncompressed one
 135         base_name = os.path.join(tmpdir2, 'archive')
 136         old_dir = os.getcwd()
 137         os.chdir(tmpdir)
 138         try:
 139             make_tarball(base_name, 'dist', compress=None)
 140         finally:
 141             os.chdir(old_dir)
 142         tarball = base_name + '.tar'
 143         self.assertTrue(os.path.exists(tarball))
 144
 145         # now for a dry_run
 146         base_name = os.path.join(tmpdir2, 'archive')
 147         old_dir = os.getcwd()
 148         os.chdir(tmpdir)
 149         try:
 150             make_tarball(base_name, 'dist', compress=None, dry_run=True)
 151         finally:
 152             os.chdir(old_dir)
 153         tarball = base_name + '.tar'
 154         self.assertTrue(os.path.exists(tarball))
 155
 156     @unittest.skipUnless(find_executable('compress'),
 157                          'The compress program is required')
 158     def test_compress_deprecated(self):
 159         tmpdir, tmpdir2, base_name =  self._create_files()
 160
 161         # using compress and testing the PendingDeprecationWarning
 162         old_dir = os.getcwd()
 163         os.chdir(tmpdir)
 164         try:
 165             with check_warnings() as w:
 166                 warnings.simplefilter("always")
 167                 make_tarball(base_name, 'dist', compress='compress')
 168         finally:
 169             os.chdir(old_dir)
 170         tarball = base_name + '.tar.Z'
 171         self.assertTrue(os.path.exists(tarball))
 172         self.assertEqual(len(w.warnings), 1)
 173
 174         # same test with dry_run
 175         os.remove(tarball)
 176         old_dir = os.getcwd()
 177         os.chdir(tmpdir)
 178         try:
 179             with check_warnings() as w:
 180                 warnings.simplefilter("always")
 181                 make_tarball(base_name, 'dist', compress='compress',
 182                              dry_run=True)
 183         finally:
 184             os.chdir(old_dir)
 185         self.assertTrue(not os.path.exists(tarball))
 186         self.assertEqual(len(w.warnings), 1)
 187
 188     @unittest.skipUnless(zlib, "Requires zlib")
 189     @unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
 190     def test_make_zipfile(self):
 191         # creating something to tar
 192         tmpdir = self.mkdtemp()
 193         self.write_file([tmpdir, 'file1'], 'xxx')
 194         self.write_file([tmpdir, 'file2'], 'xxx')
 195
 196         tmpdir2 = self.mkdtemp()
 197         base_name = os.path.join(tmpdir2, 'archive')
 198         make_zipfile(base_name, tmpdir)
 199
 200         # check if the compressed tarball was created
 201         tarball = base_name + '.zip'
 202
 203     def test_check_archive_formats(self):
 204         self.assertEqual(check_archive_formats(['gztar', 'xxx', 'zip']),
 205                          'xxx')
 206         self.assertEqual(check_archive_formats(['gztar', 'zip']), None)
 207
 208     def test_make_archive(self):
 209         tmpdir = self.mkdtemp()
 210         base_name = os.path.join(tmpdir, 'archive')
 211         self.assertRaises(ValueError, make_archive, base_name, 'xxx')
 212
 213     @unittest.skipUnless(zlib, "Requires zlib")
 214     def test_make_archive_owner_group(self):
 215         # testing make_archive with owner and group, with various combinations
 216         # this works even if there's not gid/uid support
 217         if UID_GID_SUPPORT:
 218             group = grp.getgrgid(0)[0]
 219             owner = pwd.getpwuid(0)[0]
 220         else:
 221             group = owner = 'root'
 222
 223         base_dir, root_dir, base_name =  self._create_files()
 224         base_name = os.path.join(self.mkdtemp() , 'archive')
 225         res = make_archive(base_name, 'zip', root_dir, base_dir, owner=owner,
 226                            group=group)
 227         self.assertTrue(os.path.exists(res))
 228
 229         res = make_archive(base_name, 'zip', root_dir, base_dir)
 230         self.assertTrue(os.path.exists(res))
 231
 232         res = make_archive(base_name, 'tar', root_dir, base_dir,
 233                            owner=owner, group=group)
 234         self.assertTrue(os.path.exists(res))
 235
 236         res = make_archive(base_name, 'tar', root_dir, base_dir,
 237                            owner='kjhkjhkjg', group='oihohoh')
 238         self.assertTrue(os.path.exists(res))
 239
 240     @unittest.skipUnless(zlib, "Requires zlib")
 241     @unittest.skipUnless(UID_GID_SUPPORT, "Requires grp and pwd support")
 242     def test_tarfile_root_owner(self):
 243         tmpdir, tmpdir2, base_name =  self._create_files()
 244         old_dir = os.getcwd()
 245         os.chdir(tmpdir)
 246         group = grp.getgrgid(0)[0]
 247         owner = pwd.getpwuid(0)[0]
 248         try:
 249             archive_name = make_tarball(base_name, 'dist', compress=None,
 250                                         owner=owner, group=group)
 251         finally:
 252             os.chdir(old_dir)
 253
 254         # check if the compressed tarball was created
 255         self.assertTrue(os.path.exists(archive_name))
 256
 257         # now checks the rights
 258         archive = tarfile.open(archive_name)
 259         try:
 260             for member in archive.getmembers():
 261                 self.assertEqual(member.uid, 0)
 262                 self.assertEqual(member.gid, 0)
 263         finally:
 264             archive.close()
 265
 266     def test_make_archive_cwd(self):
 267         current_dir = os.getcwd()
 268         def _breaks(*args, **kw):
 269             raise RuntimeError()
 270         ARCHIVE_FORMATS['xxx'] = (_breaks, [], 'xxx file')
 271         try:
 272             try:
 273                 make_archive('xxx', 'xxx', root_dir=self.mkdtemp())
 274             except:
 275                 pass
 276             self.assertEqual(os.getcwd(), current_dir)
 277         finally:
 278             del ARCHIVE_FORMATS['xxx']
 279
 280 def test_suite():
 281     return unittest.makeSuite(ArchiveUtilTestCase)
 282
 283 if __name__ == "__main__":
 284     unittest.main(defaultTest="test_suite")