setuptools-0.6c16dev3.egg/setuptools/tests/__init__.py

   1 """Tests for the 'setuptools' package"""
   2 from unittest import TestSuite, TestCase, makeSuite, defaultTestLoader
   3 import distutils.core, distutils.cmd
   4 from distutils.errors import DistutilsOptionError, DistutilsPlatformError
   5 from distutils.errors import DistutilsSetupError
   6 import setuptools, setuptools.dist
   7 from setuptools import Feature
   8 from distutils.core import Extension
   9 extract_constant, get_module_constant = None, None
  10 from setuptools.depends import *
  11 from distutils.version import StrictVersion, LooseVersion
  12 from distutils.util import convert_path
  13 import sys, os.path
  14
  15 def additional_tests():
  16     import doctest, unittest
  17     suite = unittest.TestSuite((
  18         doctest.DocFileSuite('api_tests.txt',
  19                              optionflags=doctest.ELLIPSIS, package=__name__,
  20                              ),
  21         ))
  22     if sys.platform == 'win32':
  23         suite.addTest(doctest.DocFileSuite('win_script_wrapper.txt'))
  24     return suite
  25
  26 def makeSetup(**args):
  27     """Return distribution from 'setup(**args)', without executing commands"""
  28
  29     distutils.core._setup_stop_after = "commandline"
  30
  31     # Don't let system command line leak into tests!
  32     args.setdefault('script_args',['install'])
  33
  34     try:
  35         return setuptools.setup(**args)
  36     finally:
  37         distutils.core_setup_stop_after = None
  38
  39
  40
  41
  42 class DependsTests(TestCase):
  43
  44     def testExtractConst(self):
  45         if not extract_constant: return  # skip on non-bytecode platforms
  46
  47         def f1():
  48             global x,y,z
  49             x = "test"
  50             y = z
  51
  52         # unrecognized name
  53         self.assertEqual(extract_constant(f1.func_code,'q', -1), None)
  54
  55         # constant assigned
  56         self.assertEqual(extract_constant(f1.func_code,'x', -1), "test")
  57
  58         # expression assigned
  59         self.assertEqual(extract_constant(f1.func_code,'y', -1), -1)
  60
  61         # recognized name, not assigned
  62         self.assertEqual(extract_constant(f1.func_code,'z', -1), None)
  63
  64
  65     def testFindModule(self):
  66         self.assertRaises(ImportError, find_module, 'no-such.-thing')
  67         self.assertRaises(ImportError, find_module, 'setuptools.non-existent')
  68         f,p,i = find_module('setuptools.tests'); f.close()
  69
  70     def testModuleExtract(self):
  71         if not get_module_constant: return  # skip on non-bytecode platforms
  72         from distutils import __version__
  73         self.assertEqual(
  74             get_module_constant('distutils','__version__'), __version__
  75         )
  76         self.assertEqual(
  77             get_module_constant('sys','version'), sys.version
  78         )
  79         self.assertEqual(
  80             get_module_constant('setuptools.tests','__doc__'),__doc__
  81         )
  82
  83     def testRequire(self):
  84         if not extract_constant: return  # skip on non-bytecode platforms
  85
  86         req = Require('Distutils','1.0.3','distutils')
  87
  88         self.assertEqual(req.name, 'Distutils')
  89         self.assertEqual(req.module, 'distutils')
  90         self.assertEqual(req.requested_version, '1.0.3')
  91         self.assertEqual(req.attribute, '__version__')
  92         self.assertEqual(req.full_name(), 'Distutils-1.0.3')
  93
  94         from distutils import __version__
  95         self.assertEqual(req.get_version(), __version__)
  96         self.failUnless(req.version_ok('1.0.9'))
  97         self.failIf(req.version_ok('0.9.1'))
  98         self.failIf(req.version_ok('unknown'))
  99
 100         self.failUnless(req.is_present())
 101         self.failUnless(req.is_current())
 102
 103         req = Require('Distutils 3000','03000','distutils',format=LooseVersion)
 104         self.failUnless(req.is_present())
 105         self.failIf(req.is_current())
 106         self.failIf(req.version_ok('unknown'))
 107
 108         req = Require('Do-what-I-mean','1.0','d-w-i-m')
 109         self.failIf(req.is_present())
 110         self.failIf(req.is_current())
 111
 112         req = Require('Tests', None, 'tests', homepage="http://example.com")
 113         self.assertEqual(req.format, None)
 114         self.assertEqual(req.attribute, None)
 115         self.assertEqual(req.requested_version, None)
 116         self.assertEqual(req.full_name(), 'Tests')
 117         self.assertEqual(req.homepage, 'http://example.com')
 118
 119         paths = [os.path.dirname(p) for p in __path__]
 120         self.failUnless(req.is_present(paths))
 121         self.failUnless(req.is_current(paths))
 122
 123
 124 class DistroTests(TestCase):
 125
 126     def setUp(self):
 127         self.e1 = Extension('bar.ext',['bar.c'])
 128         self.e2 = Extension('c.y', ['y.c'])
 129
 130         self.dist = makeSetup(
 131             packages=['a', 'a.b', 'a.b.c', 'b', 'c'],
 132             py_modules=['b.d','x'],
 133             ext_modules = (self.e1, self.e2),
 134             package_dir = {},
 135         )
 136
 137
 138     def testDistroType(self):
 139         self.failUnless(isinstance(self.dist,setuptools.dist.Distribution))
 140
 141
 142     def testExcludePackage(self):
 143         self.dist.exclude_package('a')
 144         self.assertEqual(self.dist.packages, ['b','c'])
 145
 146         self.dist.exclude_package('b')
 147         self.assertEqual(self.dist.packages, ['c'])
 148         self.assertEqual(self.dist.py_modules, ['x'])
 149         self.assertEqual(self.dist.ext_modules, [self.e1, self.e2])
 150
 151         self.dist.exclude_package('c')
 152         self.assertEqual(self.dist.packages, [])
 153         self.assertEqual(self.dist.py_modules, ['x'])
 154         self.assertEqual(self.dist.ext_modules, [self.e1])
 155
 156         # test removals from unspecified options
 157         makeSetup().exclude_package('x')
 158
 159
 160
 161
 162
 163
 164
 165     def testIncludeExclude(self):
 166         # remove an extension
 167         self.dist.exclude(ext_modules=[self.e1])
 168         self.assertEqual(self.dist.ext_modules, [self.e2])
 169
 170         # add it back in
 171         self.dist.include(ext_modules=[self.e1])
 172         self.assertEqual(self.dist.ext_modules, [self.e2, self.e1])
 173
 174         # should not add duplicate
 175         self.dist.include(ext_modules=[self.e1])
 176         self.assertEqual(self.dist.ext_modules, [self.e2, self.e1])
 177
 178     def testExcludePackages(self):
 179         self.dist.exclude(packages=['c','b','a'])
 180         self.assertEqual(self.dist.packages, [])
 181         self.assertEqual(self.dist.py_modules, ['x'])
 182         self.assertEqual(self.dist.ext_modules, [self.e1])
 183
 184     def testEmpty(self):
 185         dist = makeSetup()
 186         dist.include(packages=['a'], py_modules=['b'], ext_modules=[self.e2])
 187         dist = makeSetup()
 188         dist.exclude(packages=['a'], py_modules=['b'], ext_modules=[self.e2])
 189
 190     def testContents(self):
 191         self.failUnless(self.dist.has_contents_for('a'))
 192         self.dist.exclude_package('a')
 193         self.failIf(self.dist.has_contents_for('a'))
 194
 195         self.failUnless(self.dist.has_contents_for('b'))
 196         self.dist.exclude_package('b')
 197         self.failIf(self.dist.has_contents_for('b'))
 198
 199         self.failUnless(self.dist.has_contents_for('c'))
 200         self.dist.exclude_package('c')
 201         self.failIf(self.dist.has_contents_for('c'))
 202
 203
 204
 205
 206     def testInvalidIncludeExclude(self):
 207         self.assertRaises(DistutilsSetupError,
 208             self.dist.include, nonexistent_option='x'
 209         )
 210         self.assertRaises(DistutilsSetupError,
 211             self.dist.exclude, nonexistent_option='x'
 212         )
 213         self.assertRaises(DistutilsSetupError,
 214             self.dist.include, packages={'x':'y'}
 215         )
 216         self.assertRaises(DistutilsSetupError,
 217             self.dist.exclude, packages={'x':'y'}
 218         )
 219         self.assertRaises(DistutilsSetupError,
 220             self.dist.include, ext_modules={'x':'y'}
 221         )
 222         self.assertRaises(DistutilsSetupError,
 223             self.dist.exclude, ext_modules={'x':'y'}
 224         )
 225
 226         self.assertRaises(DistutilsSetupError,
 227             self.dist.include, package_dir=['q']
 228         )
 229         self.assertRaises(DistutilsSetupError,
 230             self.dist.exclude, package_dir=['q']
 231         )
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247 class FeatureTests(TestCase):
 248
 249     def setUp(self):
 250         self.req = Require('Distutils','1.0.3','distutils')
 251         self.dist = makeSetup(
 252             features={
 253                 'foo': Feature("foo",standard=True,require_features=['baz',self.req]),
 254                 'bar': Feature("bar",  standard=True, packages=['pkg.bar'],
 255                                py_modules=['bar_et'], remove=['bar.ext'],
 256                        ),
 257                 'baz': Feature(
 258                         "baz", optional=False, packages=['pkg.baz'],
 259                         scripts = ['scripts/baz_it'],
 260                         libraries=[('libfoo','foo/foofoo.c')]
 261                        ),
 262                 'dwim': Feature("DWIM", available=False, remove='bazish'),
 263             },
 264             script_args=['--without-bar', 'install'],
 265             packages = ['pkg.bar', 'pkg.foo'],
 266             py_modules = ['bar_et', 'bazish'],
 267             ext_modules = [Extension('bar.ext',['bar.c'])]
 268         )
 269
 270     def testDefaults(self):
 271         self.failIf(
 272             Feature(
 273                 "test",standard=True,remove='x',available=False
 274             ).include_by_default()
 275         )
 276         self.failUnless(
 277             Feature("test",standard=True,remove='x').include_by_default()
 278         )
 279         # Feature must have either kwargs, removes, or require_features
 280         self.assertRaises(DistutilsSetupError, Feature, "test")
 281
 282     def testAvailability(self):
 283         self.assertRaises(
 284             DistutilsPlatformError,
 285             self.dist.features['dwim'].include_in, self.dist
 286         )
 287
 288     def testFeatureOptions(self):
 289         dist = self.dist
 290         self.failUnless(
 291             ('with-dwim',None,'include DWIM') in dist.feature_options
 292         )
 293         self.failUnless(
 294             ('without-dwim',None,'exclude DWIM (default)') in dist.feature_options
 295         )
 296         self.failUnless(
 297             ('with-bar',None,'include bar (default)') in dist.feature_options
 298         )
 299         self.failUnless(
 300             ('without-bar',None,'exclude bar') in dist.feature_options
 301         )
 302         self.assertEqual(dist.feature_negopt['without-foo'],'with-foo')
 303         self.assertEqual(dist.feature_negopt['without-bar'],'with-bar')
 304         self.assertEqual(dist.feature_negopt['without-dwim'],'with-dwim')
 305         self.failIf('without-baz' in dist.feature_negopt)
 306
 307     def testUseFeatures(self):
 308         dist = self.dist
 309         self.assertEqual(dist.with_foo,1)
 310         self.assertEqual(dist.with_bar,0)
 311         self.assertEqual(dist.with_baz,1)
 312         self.failIf('bar_et' in dist.py_modules)
 313         self.failIf('pkg.bar' in dist.packages)
 314         self.failUnless('pkg.baz' in dist.packages)
 315         self.failUnless('scripts/baz_it' in dist.scripts)
 316         self.failUnless(('libfoo','foo/foofoo.c') in dist.libraries)
 317         self.assertEqual(dist.ext_modules,[])
 318         self.assertEqual(dist.require_features, [self.req])
 319
 320         # If we ask for bar, it should fail because we explicitly disabled
 321         # it on the command line
 322         self.assertRaises(DistutilsOptionError, dist.include_feature, 'bar')
 323
 324     def testFeatureWithInvalidRemove(self):
 325         self.assertRaises(
 326             SystemExit, makeSetup, features = {'x':Feature('x', remove='y')}
 327         )
 328
 329 class TestCommandTests(TestCase):
 330
 331     def testTestIsCommand(self):
 332         test_cmd = makeSetup().get_command_obj('test')
 333         self.failUnless(isinstance(test_cmd, distutils.cmd.Command))
 334
 335     def testLongOptSuiteWNoDefault(self):
 336         ts1 = makeSetup(script_args=['test','--test-suite=foo.tests.suite'])
 337         ts1 = ts1.get_command_obj('test')
 338         ts1.ensure_finalized()
 339         self.assertEqual(ts1.test_suite, 'foo.tests.suite')
 340
 341     def testDefaultSuite(self):
 342         ts2 = makeSetup(test_suite='bar.tests.suite').get_command_obj('test')
 343         ts2.ensure_finalized()
 344         self.assertEqual(ts2.test_suite, 'bar.tests.suite')
 345
 346     def testDefaultWModuleOnCmdLine(self):
 347         ts3 = makeSetup(
 348             test_suite='bar.tests',
 349             script_args=['test','-m','foo.tests']
 350         ).get_command_obj('test')
 351         ts3.ensure_finalized()
 352         self.assertEqual(ts3.test_module, 'foo.tests')
 353         self.assertEqual(ts3.test_suite,  'foo.tests.test_suite')
 354
 355     def testConflictingOptions(self):
 356         ts4 = makeSetup(
 357             script_args=['test','-m','bar.tests', '-s','foo.tests.suite']
 358         ).get_command_obj('test')
 359         self.assertRaises(DistutilsOptionError, ts4.ensure_finalized)
 360
 361     def testNoSuite(self):
 362         ts5 = makeSetup().get_command_obj('test')
 363         ts5.ensure_finalized()
 364         self.assertEqual(ts5.test_suite, None)
 365
 366
 367
 368
 369