Lib/distutils/tests/test_sdist.py

   1 """Tests for distutils.command.sdist."""
   2 import os
   3 import unittest
   4 import shutil
   5 import zipfile
   6 import tarfile
   7
   8 # zlib is not used here, but if it's not available
   9 # the tests that use zipfile may fail
  10 try:
  11     import zlib
  12 except ImportError:
  13     zlib = None
  14
  15 try:
  16     import grp
  17     import pwd
  18     UID_GID_SUPPORT = True
  19 except ImportError:
  20     UID_GID_SUPPORT = False
  21
  22 from os.path import join
  23 import sys
  24 import tempfile
  25 import warnings
  26
  27 from test.test_support import check_warnings
  28 from test.test_support import captured_stdout
  29
  30 from distutils.command.sdist import sdist
  31 from distutils.command.sdist import show_formats
  32 from distutils.core import Distribution
  33 from distutils.tests.test_config import PyPIRCCommandTestCase
  34 from distutils.errors import DistutilsExecError, DistutilsOptionError
  35 from distutils.spawn import find_executable
  36 from distutils.tests import support
  37 from distutils.log import WARN
  38 from distutils.archive_util import ARCHIVE_FORMATS
  39
  40 SETUP_PY = """
  41 from distutils.core import setup
  42 import somecode
  43
  44 setup(name='fake')
  45 """
  46
  47 MANIFEST = """\
  48 README
  49 inroot.txt
  50 setup.py
  51 data%(sep)sdata.dt
  52 scripts%(sep)sscript.py
  53 some%(sep)sfile.txt
  54 some%(sep)sother_file.txt
  55 somecode%(sep)s__init__.py
  56 somecode%(sep)sdoc.dat
  57 somecode%(sep)sdoc.txt
  58 """
  59
  60 class SDistTestCase(PyPIRCCommandTestCase):
  61
  62     def setUp(self):
  63         # PyPIRCCommandTestCase creates a temp dir already
  64         # and put it in self.tmp_dir
  65         super(SDistTestCase, self).setUp()
  66         # setting up an environment
  67         self.old_path = os.getcwd()
  68         os.mkdir(join(self.tmp_dir, 'somecode'))
  69         os.mkdir(join(self.tmp_dir, 'dist'))
  70         # a package, and a README
  71         self.write_file((self.tmp_dir, 'README'), 'xxx')
  72         self.write_file((self.tmp_dir, 'somecode', '__init__.py'), '#')
  73         self.write_file((self.tmp_dir, 'setup.py'), SETUP_PY)
  74         os.chdir(self.tmp_dir)
  75
  76     def tearDown(self):
  77         # back to normal
  78         os.chdir(self.old_path)
  79         super(SDistTestCase, self).tearDown()
  80
  81     def get_cmd(self, metadata=None):
  82         """Returns a cmd"""
  83         if metadata is None:
  84             metadata = {'name': 'fake', 'version': '1.0',
  85                         'url': 'xxx', 'author': 'xxx',
  86                         'author_email': 'xxx'}
  87         dist = Distribution(metadata)
  88         dist.script_name = 'setup.py'
  89         dist.packages = ['somecode']
  90         dist.include_package_data = True
  91         cmd = sdist(dist)
  92         cmd.dist_dir = 'dist'
  93         def _warn(*args):
  94             pass
  95         cmd.warn = _warn
  96         return dist, cmd
  97
  98     @unittest.skipUnless(zlib, "requires zlib")
  99     def test_prune_file_list(self):
 100         # this test creates a package with some vcs dirs in it
 101         # and launch sdist to make sure they get pruned
 102         # on all systems
 103
 104         # creating VCS directories with some files in them
 105         os.mkdir(join(self.tmp_dir, 'somecode', '.svn'))
 106         self.write_file((self.tmp_dir, 'somecode', '.svn', 'ok.py'), 'xxx')
 107
 108         os.mkdir(join(self.tmp_dir, 'somecode', '.hg'))
 109         self.write_file((self.tmp_dir, 'somecode', '.hg',
 110                          'ok'), 'xxx')
 111
 112         os.mkdir(join(self.tmp_dir, 'somecode', '.git'))
 113         self.write_file((self.tmp_dir, 'somecode', '.git',
 114                          'ok'), 'xxx')
 115
 116         # now building a sdist
 117         dist, cmd = self.get_cmd()
 118
 119         # zip is available universally
 120         # (tar might not be installed under win32)
 121         cmd.formats = ['zip']
 122
 123         cmd.ensure_finalized()
 124         cmd.run()
 125
 126         # now let's check what we have
 127         dist_folder = join(self.tmp_dir, 'dist')
 128         files = os.listdir(dist_folder)
 129         self.assertEquals(files, ['fake-1.0.zip'])
 130
 131         zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
 132         try:
 133             content = zip_file.namelist()
 134         finally:
 135             zip_file.close()
 136
 137         # making sure everything has been pruned correctly
 138         self.assertEquals(len(content), 4)
 139
 140     @unittest.skipUnless(zlib, "requires zlib")
 141     def test_make_distribution(self):
 142
 143         # check if tar and gzip are installed
 144         if (find_executable('tar') is None or
 145             find_executable('gzip') is None):
 146             return
 147
 148         # now building a sdist
 149         dist, cmd = self.get_cmd()
 150
 151         # creating a gztar then a tar
 152         cmd.formats = ['gztar', 'tar']
 153         cmd.ensure_finalized()
 154         cmd.run()
 155
 156         # making sure we have two files
 157         dist_folder = join(self.tmp_dir, 'dist')
 158         result = os.listdir(dist_folder)
 159         result.sort()
 160         self.assertEquals(result,
 161                           ['fake-1.0.tar', 'fake-1.0.tar.gz'] )
 162
 163         os.remove(join(dist_folder, 'fake-1.0.tar'))
 164         os.remove(join(dist_folder, 'fake-1.0.tar.gz'))
 165
 166         # now trying a tar then a gztar
 167         cmd.formats = ['tar', 'gztar']
 168
 169         cmd.ensure_finalized()
 170         cmd.run()
 171
 172         result = os.listdir(dist_folder)
 173         result.sort()
 174         self.assertEquals(result,
 175                 ['fake-1.0.tar', 'fake-1.0.tar.gz'])
 176
 177     @unittest.skipUnless(zlib, "requires zlib")
 178     def test_add_defaults(self):
 179
 180         # http://bugs.python.org/issue2279
 181
 182         # add_default should also include
 183         # data_files and package_data
 184         dist, cmd = self.get_cmd()
 185
 186         # filling data_files by pointing files
 187         # in package_data
 188         dist.package_data = {'': ['*.cfg', '*.dat'],
 189                              'somecode': ['*.txt']}
 190         self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#')
 191         self.write_file((self.tmp_dir, 'somecode', 'doc.dat'), '#')
 192
 193         # adding some data in data_files
 194         data_dir = join(self.tmp_dir, 'data')
 195         os.mkdir(data_dir)
 196         self.write_file((data_dir, 'data.dt'), '#')
 197         some_dir = join(self.tmp_dir, 'some')
 198         os.mkdir(some_dir)
 199         self.write_file((self.tmp_dir, 'inroot.txt'), '#')
 200         self.write_file((some_dir, 'file.txt'), '#')
 201         self.write_file((some_dir, 'other_file.txt'), '#')
 202
 203         dist.data_files = [('data', ['data/data.dt',
 204                                      'inroot.txt',
 205                                      'notexisting']),
 206                            'some/file.txt',
 207                            'some/other_file.txt']
 208
 209         # adding a script
 210         script_dir = join(self.tmp_dir, 'scripts')
 211         os.mkdir(script_dir)
 212         self.write_file((script_dir, 'script.py'), '#')
 213         dist.scripts = [join('scripts', 'script.py')]
 214
 215         cmd.formats = ['zip']
 216         cmd.use_defaults = True
 217
 218         cmd.ensure_finalized()
 219         cmd.run()
 220
 221         # now let's check what we have
 222         dist_folder = join(self.tmp_dir, 'dist')
 223         files = os.listdir(dist_folder)
 224         self.assertEquals(files, ['fake-1.0.zip'])
 225
 226         zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
 227         try:
 228             content = zip_file.namelist()
 229         finally:
 230             zip_file.close()
 231
 232         # making sure everything was added
 233         self.assertEquals(len(content), 11)
 234
 235         # checking the MANIFEST
 236         manifest = open(join(self.tmp_dir, 'MANIFEST')).read()
 237         self.assertEquals(manifest, MANIFEST % {'sep': os.sep})
 238
 239     @unittest.skipUnless(zlib, "requires zlib")
 240     def test_metadata_check_option(self):
 241         # testing the `medata-check` option
 242         dist, cmd = self.get_cmd(metadata={})
 243
 244         # this should raise some warnings !
 245         # with the `check` subcommand
 246         cmd.ensure_finalized()
 247         cmd.run()
 248         warnings = self.get_logs(WARN)
 249         self.assertEquals(len(warnings), 2)
 250
 251         # trying with a complete set of metadata
 252         self.clear_logs()
 253         dist, cmd = self.get_cmd()
 254         cmd.ensure_finalized()
 255         cmd.metadata_check = 0
 256         cmd.run()
 257         warnings = self.get_logs(WARN)
 258         self.assertEquals(len(warnings), 0)
 259
 260     def test_check_metadata_deprecated(self):
 261         # makes sure make_metadata is deprecated
 262         dist, cmd = self.get_cmd()
 263         with check_warnings() as w:
 264             warnings.simplefilter("always")
 265             cmd.check_metadata()
 266             self.assertEquals(len(w.warnings), 1)
 267
 268     def test_show_formats(self):
 269         with captured_stdout() as stdout:
 270             show_formats()
 271
 272         # the output should be a header line + one line per format
 273         num_formats = len(ARCHIVE_FORMATS.keys())
 274         output = [line for line in stdout.getvalue().split('\n')
 275                   if line.strip().startswith('--formats=')]
 276         self.assertEquals(len(output), num_formats)
 277
 278     def test_finalize_options(self):
 279
 280         dist, cmd = self.get_cmd()
 281         cmd.finalize_options()
 282
 283         # default options set by finalize
 284         self.assertEquals(cmd.manifest, 'MANIFEST')
 285         self.assertEquals(cmd.template, 'MANIFEST.in')
 286         self.assertEquals(cmd.dist_dir, 'dist')
 287
 288         # formats has to be a string splitable on (' ', ',') or
 289         # a stringlist
 290         cmd.formats = 1
 291         self.assertRaises(DistutilsOptionError, cmd.finalize_options)
 292         cmd.formats = ['zip']
 293         cmd.finalize_options()
 294
 295         # formats has to be known
 296         cmd.formats = 'supazipa'
 297         self.assertRaises(DistutilsOptionError, cmd.finalize_options)
 298
 299     @unittest.skipUnless(zlib, "requires zlib")
 300     @unittest.skipUnless(UID_GID_SUPPORT, "Requires grp and pwd support")
 301     def test_make_distribution_owner_group(self):
 302
 303         # check if tar and gzip are installed
 304         if (find_executable('tar') is None or
 305             find_executable('gzip') is None):
 306             return
 307
 308         # now building a sdist
 309         dist, cmd = self.get_cmd()
 310
 311         # creating a gztar and specifying the owner+group
 312         cmd.formats = ['gztar']
 313         cmd.owner = pwd.getpwuid(0)[0]
 314         cmd.group = grp.getgrgid(0)[0]
 315         cmd.ensure_finalized()
 316         cmd.run()
 317
 318         # making sure we have the good rights
 319         archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
 320         archive = tarfile.open(archive_name)
 321         try:
 322             for member in archive.getmembers():
 323                 self.assertEquals(member.uid, 0)
 324                 self.assertEquals(member.gid, 0)
 325         finally:
 326             archive.close()
 327
 328         # building a sdist again
 329         dist, cmd = self.get_cmd()
 330
 331         # creating a gztar
 332         cmd.formats = ['gztar']
 333         cmd.ensure_finalized()
 334         cmd.run()
 335
 336         # making sure we have the good rights
 337         archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
 338         archive = tarfile.open(archive_name)
 339
 340         # note that we are not testing the group ownership here
 341         # because, depending on the platforms and the container
 342         # rights (see #7408)
 343         try:
 344             for member in archive.getmembers():
 345                 self.assertEquals(member.uid, os.getuid())
 346         finally:
 347             archive.close()
 348
 349 def test_suite():
 350     return unittest.makeSuite(SDistTestCase)
 351
 352 if __name__ == "__main__":
 353     unittest.main(defaultTest="test_suite")