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
15 def additional_tests():
16 import doctest, unittest
17 suite = unittest.TestSuite((
18 doctest.DocFileSuite('api_tests.txt',
19 optionflags=doctest.ELLIPSIS, package=__name__,
22 if sys.platform == 'win32':
23 suite.addTest(doctest.DocFileSuite('win_script_wrapper.txt'))
26 def makeSetup(**args):
27 """Return distribution from 'setup(**args)', without executing commands"""
29 distutils.core._setup_stop_after = "commandline"
31 # Don't let system command line leak into tests!
32 args.setdefault('script_args',['install'])
35 return setuptools.setup(**args)
37 distutils.core_setup_stop_after = None
42 class DependsTests(TestCase):
44 def testExtractConst(self):
45 if not extract_constant: return # skip on non-bytecode platforms
53 self.assertEqual(extract_constant(f1.func_code,'q', -1), None)
56 self.assertEqual(extract_constant(f1.func_code,'x', -1), "test")
59 self.assertEqual(extract_constant(f1.func_code,'y', -1), -1)
61 # recognized name, not assigned
62 self.assertEqual(extract_constant(f1.func_code,'z', -1), None)
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()
70 def testModuleExtract(self):
71 if not get_module_constant: return # skip on non-bytecode platforms
72 from distutils import __version__
74 get_module_constant('distutils','__version__'), __version__
77 get_module_constant('sys','version'), sys.version
80 get_module_constant('setuptools.tests','__doc__'),__doc__
83 def testRequire(self):
84 if not extract_constant: return # skip on non-bytecode platforms
86 req = Require('Distutils','1.0.3','distutils')
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')
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'))
100 self.failUnless(req.is_present())
101 self.failUnless(req.is_current())
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'))
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())
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')
119 paths = [os.path.dirname(p) for p in __path__]
120 self.failUnless(req.is_present(paths))
121 self.failUnless(req.is_current(paths))
124 class DistroTests(TestCase):
127 self.e1 = Extension('bar.ext',['bar.c'])
128 self.e2 = Extension('c.y', ['y.c'])
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),
138 def testDistroType(self):
139 self.failUnless(isinstance(self.dist,setuptools.dist.Distribution))
142 def testExcludePackage(self):
143 self.dist.exclude_package('a')
144 self.assertEqual(self.dist.packages, ['b','c'])
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])
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])
156 # test removals from unspecified options
157 makeSetup().exclude_package('x')
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])
171 self.dist.include(ext_modules=[self.e1])
172 self.assertEqual(self.dist.ext_modules, [self.e2, self.e1])
174 # should not add duplicate
175 self.dist.include(ext_modules=[self.e1])
176 self.assertEqual(self.dist.ext_modules, [self.e2, self.e1])
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])
186 dist.include(packages=['a'], py_modules=['b'], ext_modules=[self.e2])
188 dist.exclude(packages=['a'], py_modules=['b'], ext_modules=[self.e2])
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'))
195 self.failUnless(self.dist.has_contents_for('b'))
196 self.dist.exclude_package('b')
197 self.failIf(self.dist.has_contents_for('b'))
199 self.failUnless(self.dist.has_contents_for('c'))
200 self.dist.exclude_package('c')
201 self.failIf(self.dist.has_contents_for('c'))
206 def testInvalidIncludeExclude(self):
207 self.assertRaises(DistutilsSetupError,
208 self.dist.include, nonexistent_option='x'
210 self.assertRaises(DistutilsSetupError,
211 self.dist.exclude, nonexistent_option='x'
213 self.assertRaises(DistutilsSetupError,
214 self.dist.include, packages={'x':'y'}
216 self.assertRaises(DistutilsSetupError,
217 self.dist.exclude, packages={'x':'y'}
219 self.assertRaises(DistutilsSetupError,
220 self.dist.include, ext_modules={'x':'y'}
222 self.assertRaises(DistutilsSetupError,
223 self.dist.exclude, ext_modules={'x':'y'}
226 self.assertRaises(DistutilsSetupError,
227 self.dist.include, package_dir=['q']
229 self.assertRaises(DistutilsSetupError,
230 self.dist.exclude, package_dir=['q']
247 class FeatureTests(TestCase):
250 self.req = Require('Distutils','1.0.3','distutils')
251 self.dist = makeSetup(
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'],
258 "baz", optional=False, packages=['pkg.baz'],
259 scripts = ['scripts/baz_it'],
260 libraries=[('libfoo','foo/foofoo.c')]
262 'dwim': Feature("DWIM", available=False, remove='bazish'),
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'])]
270 def testDefaults(self):
273 "test",standard=True,remove='x',available=False
274 ).include_by_default()
277 Feature("test",standard=True,remove='x').include_by_default()
279 # Feature must have either kwargs, removes, or require_features
280 self.assertRaises(DistutilsSetupError, Feature, "test")
282 def testAvailability(self):
284 DistutilsPlatformError,
285 self.dist.features['dwim'].include_in, self.dist
288 def testFeatureOptions(self):
291 ('with-dwim',None,'include DWIM') in dist.feature_options
294 ('without-dwim',None,'exclude DWIM (default)') in dist.feature_options
297 ('with-bar',None,'include bar (default)') in dist.feature_options
300 ('without-bar',None,'exclude bar') in dist.feature_options
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)
307 def testUseFeatures(self):
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])
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')
324 def testFeatureWithInvalidRemove(self):
326 SystemExit, makeSetup, features = {'x':Feature('x', remove='y')}
329 class TestCommandTests(TestCase):
331 def testTestIsCommand(self):
332 test_cmd = makeSetup().get_command_obj('test')
333 self.failUnless(isinstance(test_cmd, distutils.cmd.Command))
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')
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')
346 def testDefaultWModuleOnCmdLine(self):
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')
355 def testConflictingOptions(self):
357 script_args=['test','-m','bar.tests', '-s','foo.tests.suite']
358 ).get_command_obj('test')
359 self.assertRaises(DistutilsOptionError, ts4.ensure_finalized)
361 def testNoSuite(self):
362 ts5 = makeSetup().get_command_obj('test')
363 ts5.ensure_finalized()
364 self.assertEqual(ts5.test_suite, None)