root / env / lib / python2.7 / site-packages / distribute-0.6.19-py2.7.egg / setuptools / tests / test_resources.py @ 1a305335
History | View | Annotate | Download (23.1 KB)
1 | 1a305335 | officers | #!/usr/bin/python
|
---|---|---|---|
2 | # -*- coding: utf-8 -*-
|
||
3 | # NOTE: the shebang and encoding lines are for ScriptHeaderTests; do not remove
|
||
4 | from unittest import TestCase, makeSuite; from pkg_resources import * |
||
5 | from setuptools.command.easy_install import get_script_header, is_sh |
||
6 | import os, pkg_resources, sys, StringIO, tempfile, shutil |
||
7 | try: frozenset |
||
8 | except NameError: |
||
9 | from sets import ImmutableSet as frozenset |
||
10 | |||
11 | class Metadata(EmptyProvider): |
||
12 | """Mock object to return metadata as if from an on-disk distribution"""
|
||
13 | |||
14 | def __init__(self,*pairs): |
||
15 | self.metadata = dict(pairs) |
||
16 | |||
17 | def has_metadata(self,name): |
||
18 | return name in self.metadata |
||
19 | |||
20 | def get_metadata(self,name): |
||
21 | return self.metadata[name] |
||
22 | |||
23 | def get_metadata_lines(self,name): |
||
24 | return yield_lines(self.get_metadata(name)) |
||
25 | |||
26 | class DistroTests(TestCase): |
||
27 | |||
28 | def testCollection(self): |
||
29 | # empty path should produce no distributions
|
||
30 | ad = Environment([], platform=None, python=None) |
||
31 | self.assertEqual(list(ad), []) |
||
32 | self.assertEqual(ad['FooPkg'],[]) |
||
33 | ad.add(Distribution.from_filename("FooPkg-1.3_1.egg"))
|
||
34 | ad.add(Distribution.from_filename("FooPkg-1.4-py2.4-win32.egg"))
|
||
35 | ad.add(Distribution.from_filename("FooPkg-1.2-py2.4.egg"))
|
||
36 | |||
37 | # Name is in there now
|
||
38 | self.assert_(ad['FooPkg']) |
||
39 | # But only 1 package
|
||
40 | self.assertEqual(list(ad), ['foopkg']) |
||
41 | |||
42 | # Distributions sort by version
|
||
43 | self.assertEqual(
|
||
44 | [dist.version for dist in ad['FooPkg']], ['1.4','1.3-1','1.2'] |
||
45 | ) |
||
46 | # Removing a distribution leaves sequence alone
|
||
47 | ad.remove(ad['FooPkg'][1]) |
||
48 | self.assertEqual(
|
||
49 | [dist.version for dist in ad['FooPkg']], ['1.4','1.2'] |
||
50 | ) |
||
51 | # And inserting adds them in order
|
||
52 | ad.add(Distribution.from_filename("FooPkg-1.9.egg"))
|
||
53 | self.assertEqual(
|
||
54 | [dist.version for dist in ad['FooPkg']], ['1.9','1.4','1.2'] |
||
55 | ) |
||
56 | |||
57 | ws = WorkingSet([]) |
||
58 | foo12 = Distribution.from_filename("FooPkg-1.2-py2.4.egg")
|
||
59 | foo14 = Distribution.from_filename("FooPkg-1.4-py2.4-win32.egg")
|
||
60 | req, = parse_requirements("FooPkg>=1.3")
|
||
61 | |||
62 | # Nominal case: no distros on path, should yield all applicable
|
||
63 | self.assertEqual(ad.best_match(req,ws).version, '1.9') |
||
64 | # If a matching distro is already installed, should return only that
|
||
65 | ws.add(foo14); self.assertEqual(ad.best_match(req,ws).version, '1.4') |
||
66 | |||
67 | # If the first matching distro is unsuitable, it's a version conflict
|
||
68 | ws = WorkingSet([]); ws.add(foo12); ws.add(foo14) |
||
69 | self.assertRaises(VersionConflict, ad.best_match, req, ws)
|
||
70 | |||
71 | # If more than one match on the path, the first one takes precedence
|
||
72 | ws = WorkingSet([]); ws.add(foo14); ws.add(foo12); ws.add(foo14); |
||
73 | self.assertEqual(ad.best_match(req,ws).version, '1.4') |
||
74 | |||
75 | def checkFooPkg(self,d): |
||
76 | self.assertEqual(d.project_name, "FooPkg") |
||
77 | self.assertEqual(d.key, "foopkg") |
||
78 | self.assertEqual(d.version, "1.3-1") |
||
79 | self.assertEqual(d.py_version, "2.4") |
||
80 | self.assertEqual(d.platform, "win32") |
||
81 | self.assertEqual(d.parsed_version, parse_version("1.3-1")) |
||
82 | |||
83 | def testDistroBasics(self): |
||
84 | d = Distribution( |
||
85 | "/some/path",
|
||
86 | project_name="FooPkg",version="1.3-1",py_version="2.4",platform="win32" |
||
87 | ) |
||
88 | self.checkFooPkg(d)
|
||
89 | |||
90 | d = Distribution("/some/path")
|
||
91 | self.assertEqual(d.py_version, sys.version[:3]) |
||
92 | self.assertEqual(d.platform, None) |
||
93 | |||
94 | def testDistroParse(self): |
||
95 | d = Distribution.from_filename("FooPkg-1.3_1-py2.4-win32.egg")
|
||
96 | self.checkFooPkg(d)
|
||
97 | d = Distribution.from_filename("FooPkg-1.3_1-py2.4-win32.egg-info")
|
||
98 | self.checkFooPkg(d)
|
||
99 | |||
100 | def testDistroMetadata(self): |
||
101 | d = Distribution( |
||
102 | "/some/path", project_name="FooPkg", py_version="2.4", platform="win32", |
||
103 | metadata = Metadata( |
||
104 | ('PKG-INFO',"Metadata-Version: 1.0\nVersion: 1.3-1\n") |
||
105 | ) |
||
106 | ) |
||
107 | self.checkFooPkg(d)
|
||
108 | |||
109 | |||
110 | def distRequires(self, txt): |
||
111 | return Distribution("/foo", metadata=Metadata(('depends.txt', txt))) |
||
112 | |||
113 | def checkRequires(self, dist, txt, extras=()): |
||
114 | self.assertEqual(
|
||
115 | list(dist.requires(extras)),
|
||
116 | list(parse_requirements(txt))
|
||
117 | ) |
||
118 | |||
119 | def testDistroDependsSimple(self): |
||
120 | for v in "Twisted>=1.5", "Twisted>=1.5\nZConfig>=2.0": |
||
121 | self.checkRequires(self.distRequires(v), v) |
||
122 | |||
123 | |||
124 | def testResolve(self): |
||
125 | ad = Environment([]); ws = WorkingSet([]) |
||
126 | # Resolving no requirements -> nothing to install
|
||
127 | self.assertEqual( list(ws.resolve([],ad)), [] ) |
||
128 | # Request something not in the collection -> DistributionNotFound
|
||
129 | self.assertRaises(
|
||
130 | DistributionNotFound, ws.resolve, parse_requirements("Foo"), ad
|
||
131 | ) |
||
132 | Foo = Distribution.from_filename( |
||
133 | "/foo_dir/Foo-1.2.egg",
|
||
134 | metadata=Metadata(('depends.txt', "[bar]\nBaz>=2.0")) |
||
135 | ) |
||
136 | ad.add(Foo); ad.add(Distribution.from_filename("Foo-0.9.egg"))
|
||
137 | |||
138 | # Request thing(s) that are available -> list to activate
|
||
139 | for i in range(3): |
||
140 | targets = list(ws.resolve(parse_requirements("Foo"), ad)) |
||
141 | self.assertEqual(targets, [Foo])
|
||
142 | map(ws.add,targets)
|
||
143 | self.assertRaises(VersionConflict, ws.resolve,
|
||
144 | parse_requirements("Foo==0.9"), ad)
|
||
145 | ws = WorkingSet([]) # reset
|
||
146 | |||
147 | # Request an extra that causes an unresolved dependency for "Baz"
|
||
148 | self.assertRaises(
|
||
149 | DistributionNotFound, ws.resolve,parse_requirements("Foo[bar]"), ad
|
||
150 | ) |
||
151 | Baz = Distribution.from_filename( |
||
152 | "/foo_dir/Baz-2.1.egg", metadata=Metadata(('depends.txt', "Foo")) |
||
153 | ) |
||
154 | ad.add(Baz) |
||
155 | |||
156 | # Activation list now includes resolved dependency
|
||
157 | self.assertEqual(
|
||
158 | list(ws.resolve(parse_requirements("Foo[bar]"), ad)), [Foo,Baz] |
||
159 | ) |
||
160 | # Requests for conflicting versions produce VersionConflict
|
||
161 | self.assertRaises( VersionConflict,
|
||
162 | ws.resolve, parse_requirements("Foo==1.2\nFoo!=1.2"), ad
|
||
163 | ) |
||
164 | |||
165 | def testDistroDependsOptions(self): |
||
166 | d = self.distRequires(""" |
||
167 | Twisted>=1.5
|
||
168 | [docgen]
|
||
169 | ZConfig>=2.0
|
||
170 | docutils>=0.3
|
||
171 | [fastcgi]
|
||
172 | fcgiapp>=0.1""")
|
||
173 | self.checkRequires(d,"Twisted>=1.5") |
||
174 | self.checkRequires(
|
||
175 | d,"Twisted>=1.5 ZConfig>=2.0 docutils>=0.3".split(), ["docgen"] |
||
176 | ) |
||
177 | self.checkRequires(
|
||
178 | d,"Twisted>=1.5 fcgiapp>=0.1".split(), ["fastcgi"] |
||
179 | ) |
||
180 | self.checkRequires(
|
||
181 | d,"Twisted>=1.5 ZConfig>=2.0 docutils>=0.3 fcgiapp>=0.1".split(),
|
||
182 | ["docgen","fastcgi"] |
||
183 | ) |
||
184 | self.checkRequires(
|
||
185 | d,"Twisted>=1.5 fcgiapp>=0.1 ZConfig>=2.0 docutils>=0.3".split(),
|
||
186 | ["fastcgi", "docgen"] |
||
187 | ) |
||
188 | self.assertRaises(UnknownExtra, d.requires, ["foo"]) |
||
189 | |||
190 | def testSetuptoolsDistributeCombination(self): |
||
191 | # Ensure that installing a 0.7-series setuptools fails. PJE says that
|
||
192 | # it will not co-exist.
|
||
193 | ws = WorkingSet([]) |
||
194 | d = Distribution( |
||
195 | "/some/path",
|
||
196 | project_name="setuptools",
|
||
197 | version="0.7a1")
|
||
198 | self.assertRaises(ValueError, ws.add, d) |
||
199 | # A 0.6-series is no problem
|
||
200 | d2 = Distribution( |
||
201 | "/some/path",
|
||
202 | project_name="setuptools",
|
||
203 | version="0.6c9")
|
||
204 | ws.add(d2) |
||
205 | |||
206 | # a unexisting version needs to work
|
||
207 | ws = WorkingSet([]) |
||
208 | d3 = Distribution( |
||
209 | "/some/path",
|
||
210 | project_name="setuptools")
|
||
211 | ws.add(d3) |
||
212 | |||
213 | |||
214 | class EntryPointTests(TestCase): |
||
215 | |||
216 | def assertfields(self, ep): |
||
217 | self.assertEqual(ep.name,"foo") |
||
218 | self.assertEqual(ep.module_name,"setuptools.tests.test_resources") |
||
219 | self.assertEqual(ep.attrs, ("EntryPointTests",)) |
||
220 | self.assertEqual(ep.extras, ("x",)) |
||
221 | self.assert_(ep.load() is EntryPointTests) |
||
222 | self.assertEqual(
|
||
223 | str(ep),
|
||
224 | "foo = setuptools.tests.test_resources:EntryPointTests [x]"
|
||
225 | ) |
||
226 | |||
227 | def setUp(self): |
||
228 | self.dist = Distribution.from_filename(
|
||
229 | "FooPkg-1.2-py2.4.egg", metadata=Metadata(('requires.txt','[x]'))) |
||
230 | |||
231 | def testBasics(self): |
||
232 | ep = EntryPoint( |
||
233 | "foo", "setuptools.tests.test_resources", ["EntryPointTests"], |
||
234 | ["x"], self.dist |
||
235 | ) |
||
236 | self.assertfields(ep)
|
||
237 | |||
238 | def testParse(self): |
||
239 | s = "foo = setuptools.tests.test_resources:EntryPointTests [x]"
|
||
240 | ep = EntryPoint.parse(s, self.dist)
|
||
241 | self.assertfields(ep)
|
||
242 | |||
243 | ep = EntryPoint.parse("bar baz= spammity[PING]")
|
||
244 | self.assertEqual(ep.name,"bar baz") |
||
245 | self.assertEqual(ep.module_name,"spammity") |
||
246 | self.assertEqual(ep.attrs, ())
|
||
247 | self.assertEqual(ep.extras, ("ping",)) |
||
248 | |||
249 | ep = EntryPoint.parse(" fizzly = wocka:foo")
|
||
250 | self.assertEqual(ep.name,"fizzly") |
||
251 | self.assertEqual(ep.module_name,"wocka") |
||
252 | self.assertEqual(ep.attrs, ("foo",)) |
||
253 | self.assertEqual(ep.extras, ())
|
||
254 | |||
255 | def testRejects(self): |
||
256 | for ep in [ |
||
257 | "foo", "x=1=2", "x=a:b:c", "q=x/na", "fez=pish:tush-z", "x=f[a]>2", |
||
258 | ]: |
||
259 | try: EntryPoint.parse(ep)
|
||
260 | except ValueError: pass |
||
261 | else: raise AssertionError("Should've been bad", ep) |
||
262 | |||
263 | def checkSubMap(self, m): |
||
264 | self.assertEqual(len(m), len(self.submap_expect)) |
||
265 | for key, ep in self.submap_expect.iteritems(): |
||
266 | self.assertEqual(repr(m.get(key)), repr(ep)) |
||
267 | |||
268 | submap_expect = dict(
|
||
269 | feature1=EntryPoint('feature1', 'somemodule', ['somefunction']), |
||
270 | feature2=EntryPoint('feature2', 'another.module', ['SomeClass'], ['extra1','extra2']), |
||
271 | feature3=EntryPoint('feature3', 'this.module', extras=['something']) |
||
272 | ) |
||
273 | submap_str = """
|
||
274 | # define features for blah blah
|
||
275 | feature1 = somemodule:somefunction
|
||
276 | feature2 = another.module:SomeClass [extra1,extra2]
|
||
277 | feature3 = this.module [something]
|
||
278 | """
|
||
279 | |||
280 | def testParseList(self): |
||
281 | self.checkSubMap(EntryPoint.parse_group("xyz", self.submap_str)) |
||
282 | self.assertRaises(ValueError, EntryPoint.parse_group, "x a", "foo=bar") |
||
283 | self.assertRaises(ValueError, EntryPoint.parse_group, "x", |
||
284 | ["foo=baz", "foo=bar"]) |
||
285 | |||
286 | def testParseMap(self): |
||
287 | m = EntryPoint.parse_map({'xyz':self.submap_str}) |
||
288 | self.checkSubMap(m['xyz']) |
||
289 | self.assertEqual(m.keys(),['xyz']) |
||
290 | m = EntryPoint.parse_map("[xyz]\n"+self.submap_str) |
||
291 | self.checkSubMap(m['xyz']) |
||
292 | self.assertEqual(m.keys(),['xyz']) |
||
293 | self.assertRaises(ValueError, EntryPoint.parse_map, ["[xyz]", "[xyz]"]) |
||
294 | self.assertRaises(ValueError, EntryPoint.parse_map, self.submap_str) |
||
295 | |||
296 | class RequirementsTests(TestCase): |
||
297 | |||
298 | def testBasics(self): |
||
299 | r = Requirement.parse("Twisted>=1.2")
|
||
300 | self.assertEqual(str(r),"Twisted>=1.2") |
||
301 | self.assertEqual(repr(r),"Requirement.parse('Twisted>=1.2')") |
||
302 | self.assertEqual(r, Requirement("Twisted", [('>=','1.2')], ())) |
||
303 | self.assertEqual(r, Requirement("twisTed", [('>=','1.2')], ())) |
||
304 | self.assertNotEqual(r, Requirement("Twisted", [('>=','2.0')], ())) |
||
305 | self.assertNotEqual(r, Requirement("Zope", [('>=','1.2')], ())) |
||
306 | self.assertNotEqual(r, Requirement("Zope", [('>=','3.0')], ())) |
||
307 | self.assertNotEqual(r, Requirement.parse("Twisted[extras]>=1.2")) |
||
308 | |||
309 | def testOrdering(self): |
||
310 | r1 = Requirement("Twisted", [('==','1.2c1'),('>=','1.2')], ()) |
||
311 | r2 = Requirement("Twisted", [('>=','1.2'),('==','1.2c1')], ()) |
||
312 | self.assertEqual(r1,r2)
|
||
313 | self.assertEqual(str(r1),str(r2)) |
||
314 | self.assertEqual(str(r2),"Twisted==1.2c1,>=1.2") |
||
315 | |||
316 | def testBasicContains(self): |
||
317 | r = Requirement("Twisted", [('>=','1.2')], ()) |
||
318 | foo_dist = Distribution.from_filename("FooPkg-1.3_1.egg")
|
||
319 | twist11 = Distribution.from_filename("Twisted-1.1.egg")
|
||
320 | twist12 = Distribution.from_filename("Twisted-1.2.egg")
|
||
321 | self.assert_(parse_version('1.2') in r) |
||
322 | self.assert_(parse_version('1.1') not in r) |
||
323 | self.assert_('1.2' in r) |
||
324 | self.assert_('1.1' not in r) |
||
325 | self.assert_(foo_dist not in r) |
||
326 | self.assert_(twist11 not in r) |
||
327 | self.assert_(twist12 in r) |
||
328 | |||
329 | def testAdvancedContains(self): |
||
330 | r, = parse_requirements("Foo>=1.2,<=1.3,==1.9,>2.0,!=2.5,<3.0,==4.5")
|
||
331 | for v in ('1.2','1.2.2','1.3','1.9','2.0.1','2.3','2.6','3.0c1','4.5'): |
||
332 | self.assert_(v in r, (v,r)) |
||
333 | for v in ('1.2c1','1.3.1','1.5','1.9.1','2.0','2.5','3.0','4.0'): |
||
334 | self.assert_(v not in r, (v,r)) |
||
335 | |||
336 | |||
337 | def testOptionsAndHashing(self): |
||
338 | r1 = Requirement.parse("Twisted[foo,bar]>=1.2")
|
||
339 | r2 = Requirement.parse("Twisted[bar,FOO]>=1.2")
|
||
340 | r3 = Requirement.parse("Twisted[BAR,FOO]>=1.2.0")
|
||
341 | self.assertEqual(r1,r2)
|
||
342 | self.assertEqual(r1,r3)
|
||
343 | self.assertEqual(r1.extras, ("foo","bar")) |
||
344 | self.assertEqual(r2.extras, ("bar","foo")) # extras are normalized |
||
345 | self.assertEqual(hash(r1), hash(r2)) |
||
346 | self.assertEqual(
|
||
347 | hash(r1), hash(("twisted", ((">=",parse_version("1.2")),), |
||
348 | frozenset(["foo","bar"]))) |
||
349 | ) |
||
350 | |||
351 | def testVersionEquality(self): |
||
352 | r1 = Requirement.parse("foo==0.3a2")
|
||
353 | r2 = Requirement.parse("foo!=0.3a4")
|
||
354 | d = Distribution.from_filename |
||
355 | |||
356 | self.assert_(d("foo-0.3a4.egg") not in r1) |
||
357 | self.assert_(d("foo-0.3a1.egg") not in r1) |
||
358 | self.assert_(d("foo-0.3a4.egg") not in r2) |
||
359 | |||
360 | self.assert_(d("foo-0.3a2.egg") in r1) |
||
361 | self.assert_(d("foo-0.3a2.egg") in r2) |
||
362 | self.assert_(d("foo-0.3a3.egg") in r2) |
||
363 | self.assert_(d("foo-0.3a5.egg") in r2) |
||
364 | |||
365 | def testDistributeSetuptoolsOverride(self): |
||
366 | # Plain setuptools or distribute mean we return distribute.
|
||
367 | self.assertEqual(
|
||
368 | Requirement.parse('setuptools').project_name, 'distribute') |
||
369 | self.assertEqual(
|
||
370 | Requirement.parse('distribute').project_name, 'distribute') |
||
371 | # setuptools lower than 0.7 means distribute
|
||
372 | self.assertEqual(
|
||
373 | Requirement.parse('setuptools==0.6c9').project_name, 'distribute') |
||
374 | self.assertEqual(
|
||
375 | Requirement.parse('setuptools==0.6c10').project_name, 'distribute') |
||
376 | self.assertEqual(
|
||
377 | Requirement.parse('setuptools>=0.6').project_name, 'distribute') |
||
378 | self.assertEqual(
|
||
379 | Requirement.parse('setuptools < 0.7').project_name, 'distribute') |
||
380 | # setuptools 0.7 and higher means setuptools.
|
||
381 | self.assertEqual(
|
||
382 | Requirement.parse('setuptools == 0.7').project_name, 'setuptools') |
||
383 | self.assertEqual(
|
||
384 | Requirement.parse('setuptools == 0.7a1').project_name, 'setuptools') |
||
385 | self.assertEqual(
|
||
386 | Requirement.parse('setuptools >= 0.7').project_name, 'setuptools') |
||
387 | |||
388 | |||
389 | |||
390 | |||
391 | |||
392 | |||
393 | |||
394 | |||
395 | |||
396 | |||
397 | |||
398 | class ParseTests(TestCase): |
||
399 | |||
400 | def testEmptyParse(self): |
||
401 | self.assertEqual(list(parse_requirements('')), []) |
||
402 | |||
403 | def testYielding(self): |
||
404 | for inp,out in [ |
||
405 | ([], []), ('x',['x']), ([[]],[]), (' x\n y', ['x','y']), |
||
406 | (['x\n\n','y'], ['x','y']), |
||
407 | ]: |
||
408 | self.assertEqual(list(pkg_resources.yield_lines(inp)),out) |
||
409 | |||
410 | def testSplitting(self): |
||
411 | self.assertEqual(
|
||
412 | list(
|
||
413 | pkg_resources.split_sections("""
|
||
414 | x
|
||
415 | [Y]
|
||
416 | z
|
||
417 |
|
||
418 | a
|
||
419 | [b ]
|
||
420 | # foo
|
||
421 | c
|
||
422 | [ d]
|
||
423 | [q]
|
||
424 | v
|
||
425 | """
|
||
426 | ) |
||
427 | ), |
||
428 | [(None,["x"]), ("Y",["z","a"]), ("b",["c"]), ("d",[]), ("q",["v"])] |
||
429 | ) |
||
430 | self.assertRaises(ValueError,list,pkg_resources.split_sections("[foo")) |
||
431 | |||
432 | def testSafeName(self): |
||
433 | self.assertEqual(safe_name("adns-python"), "adns-python") |
||
434 | self.assertEqual(safe_name("WSGI Utils"), "WSGI-Utils") |
||
435 | self.assertEqual(safe_name("WSGI Utils"), "WSGI-Utils") |
||
436 | self.assertEqual(safe_name("Money$$$Maker"), "Money-Maker") |
||
437 | self.assertNotEqual(safe_name("peak.web"), "peak-web") |
||
438 | |||
439 | def testSafeVersion(self): |
||
440 | self.assertEqual(safe_version("1.2-1"), "1.2-1") |
||
441 | self.assertEqual(safe_version("1.2 alpha"), "1.2.alpha") |
||
442 | self.assertEqual(safe_version("2.3.4 20050521"), "2.3.4.20050521") |
||
443 | self.assertEqual(safe_version("Money$$$Maker"), "Money-Maker") |
||
444 | self.assertEqual(safe_version("peak.web"), "peak.web") |
||
445 | |||
446 | def testSimpleRequirements(self): |
||
447 | self.assertEqual(
|
||
448 | list(parse_requirements('Twis-Ted>=1.2-1')), |
||
449 | [Requirement('Twis-Ted',[('>=','1.2-1')], ())] |
||
450 | ) |
||
451 | self.assertEqual(
|
||
452 | list(parse_requirements('Twisted >=1.2, \ # more\n<2.0')), |
||
453 | [Requirement('Twisted',[('>=','1.2'),('<','2.0')], ())] |
||
454 | ) |
||
455 | self.assertEqual(
|
||
456 | Requirement.parse("FooBar==1.99a3"),
|
||
457 | Requirement("FooBar", [('==','1.99a3')], ()) |
||
458 | ) |
||
459 | self.assertRaises(ValueError,Requirement.parse,">=2.3") |
||
460 | self.assertRaises(ValueError,Requirement.parse,"x\\") |
||
461 | self.assertRaises(ValueError,Requirement.parse,"x==2 q") |
||
462 | self.assertRaises(ValueError,Requirement.parse,"X==1\nY==2") |
||
463 | self.assertRaises(ValueError,Requirement.parse,"#") |
||
464 | |||
465 | def testVersionEquality(self): |
||
466 | def c(s1,s2): |
||
467 | p1, p2 = parse_version(s1),parse_version(s2) |
||
468 | self.assertEqual(p1,p2, (s1,s2,p1,p2))
|
||
469 | |||
470 | c('1.2-rc1', '1.2rc1') |
||
471 | c('0.4', '0.4.0') |
||
472 | c('0.4.0.0', '0.4.0') |
||
473 | c('0.4.0-0', '0.4-0') |
||
474 | c('0pl1', '0.0pl1') |
||
475 | c('0pre1', '0.0c1') |
||
476 | c('0.0.0preview1', '0c1') |
||
477 | c('0.0c1', '0-rc1') |
||
478 | c('1.2a1', '1.2.a.1'); c('1.2...a', '1.2a') |
||
479 | |||
480 | def testVersionOrdering(self): |
||
481 | def c(s1,s2): |
||
482 | p1, p2 = parse_version(s1),parse_version(s2) |
||
483 | self.assert_(p1<p2, (s1,s2,p1,p2))
|
||
484 | |||
485 | c('2.1','2.1.1') |
||
486 | c('2a1','2b0') |
||
487 | c('2a1','2.1') |
||
488 | c('2.3a1', '2.3') |
||
489 | c('2.1-1', '2.1-2') |
||
490 | c('2.1-1', '2.1.1') |
||
491 | c('2.1', '2.1pl4') |
||
492 | c('2.1a0-20040501', '2.1') |
||
493 | c('1.1', '02.1') |
||
494 | c('A56','B27') |
||
495 | c('3.2', '3.2.pl0') |
||
496 | c('3.2-1', '3.2pl1') |
||
497 | c('3.2pl1', '3.2pl1-1') |
||
498 | c('0.4', '4.0') |
||
499 | c('0.0.4', '0.4.0') |
||
500 | c('0pl1', '0.4pl1') |
||
501 | c('2.1.0-rc1','2.1.0') |
||
502 | c('2.1dev','2.1a0') |
||
503 | |||
504 | torture ="""
|
||
505 | 0.80.1-3 0.80.1-2 0.80.1-1 0.79.9999+0.80.0pre4-1
|
||
506 | 0.79.9999+0.80.0pre2-3 0.79.9999+0.80.0pre2-2
|
||
507 | 0.77.2-1 0.77.1-1 0.77.0-1
|
||
508 | """.split()
|
||
509 | |||
510 | for p,v1 in enumerate(torture): |
||
511 | for v2 in torture[p+1:]: |
||
512 | c(v2,v1) |
||
513 | |||
514 | |||
515 | |||
516 | |||
517 | |||
518 | |||
519 | |||
520 | |||
521 | class ScriptHeaderTests(TestCase): |
||
522 | non_ascii_exe = '/Users/José/bin/python'
|
||
523 | |||
524 | def test_get_script_header(self): |
||
525 | if not sys.platform.startswith('java') or not is_sh(sys.executable): |
||
526 | # This test is for non-Jython platforms
|
||
527 | self.assertEqual(get_script_header('#!/usr/local/bin/python'), |
||
528 | '#!%s\n' % os.path.normpath(sys.executable))
|
||
529 | self.assertEqual(get_script_header('#!/usr/bin/python -x'), |
||
530 | '#!%s -x\n' % os.path.normpath(sys.executable))
|
||
531 | self.assertEqual(get_script_header('#!/usr/bin/python', |
||
532 | executable=self.non_ascii_exe),
|
||
533 | '#!%s -x\n' % self.non_ascii_exe) |
||
534 | |||
535 | def test_get_script_header_jython_workaround(self): |
||
536 | # This test doesn't work with Python 3 in some locales
|
||
537 | if (sys.version_info >= (3,) and os.environ.get("LC_CTYPE") |
||
538 | in (None, "C", "POSIX")): |
||
539 | return
|
||
540 | platform = sys.platform |
||
541 | sys.platform = 'java1.5.0_13'
|
||
542 | stdout = sys.stdout |
||
543 | try:
|
||
544 | # A mock sys.executable that uses a shebang line (this file)
|
||
545 | exe = os.path.normpath(os.path.splitext(__file__)[0] + '.py') |
||
546 | self.assertEqual(
|
||
547 | get_script_header('#!/usr/local/bin/python', executable=exe),
|
||
548 | '#!/usr/bin/env %s\n' % exe)
|
||
549 | |||
550 | # Ensure we generate what is basically a broken shebang line
|
||
551 | # when there's options, with a warning emitted
|
||
552 | sys.stdout = sys.stderr = StringIO.StringIO() |
||
553 | self.assertEqual(get_script_header('#!/usr/bin/python -x', |
||
554 | executable=exe), |
||
555 | '#!%s -x\n' % exe)
|
||
556 | self.assert_('Unable to adapt shebang line' in sys.stdout.getvalue()) |
||
557 | sys.stdout = sys.stderr = StringIO.StringIO() |
||
558 | self.assertEqual(get_script_header('#!/usr/bin/python', |
||
559 | executable=self.non_ascii_exe),
|
||
560 | '#!%s -x\n' % self.non_ascii_exe) |
||
561 | self.assert_('Unable to adapt shebang line' in sys.stdout.getvalue()) |
||
562 | finally:
|
||
563 | sys.platform = platform |
||
564 | sys.stdout = stdout |
||
565 | |||
566 | |||
567 | |||
568 | |||
569 | class NamespaceTests(TestCase): |
||
570 | |||
571 | def setUp(self): |
||
572 | self._ns_pkgs = pkg_resources._namespace_packages.copy()
|
||
573 | self._tmpdir = tempfile.mkdtemp(prefix="tests-distribute-") |
||
574 | os.makedirs(os.path.join(self._tmpdir, "site-pkgs")) |
||
575 | self._prev_sys_path = sys.path[:]
|
||
576 | sys.path.append(os.path.join(self._tmpdir, "site-pkgs")) |
||
577 | |||
578 | def tearDown(self): |
||
579 | shutil.rmtree(self._tmpdir)
|
||
580 | pkg_resources._namespace_packages = self._ns_pkgs.copy()
|
||
581 | sys.path = self._prev_sys_path[:]
|
||
582 | |||
583 | def test_two_levels_deep(self): |
||
584 | """
|
||
585 | Test nested namespace packages
|
||
586 | Create namespace packages in the following tree :
|
||
587 | site-packages-1/pkg1/pkg2
|
||
588 | site-packages-2/pkg1/pkg2
|
||
589 | Check both are in the _namespace_packages dict and that their __path__
|
||
590 | is correct
|
||
591 | """
|
||
592 | sys.path.append(os.path.join(self._tmpdir, "site-pkgs2")) |
||
593 | os.makedirs(os.path.join(self._tmpdir, "site-pkgs", "pkg1", "pkg2")) |
||
594 | os.makedirs(os.path.join(self._tmpdir, "site-pkgs2", "pkg1", "pkg2")) |
||
595 | ns_str = "__import__('pkg_resources').declare_namespace(__name__)\n"
|
||
596 | for site in ["site-pkgs", "site-pkgs2"]: |
||
597 | pkg1_init = open(os.path.join(self._tmpdir, site, |
||
598 | "pkg1", "__init__.py"), "w") |
||
599 | pkg1_init.write(ns_str) |
||
600 | pkg1_init.close() |
||
601 | pkg2_init = open(os.path.join(self._tmpdir, site, |
||
602 | "pkg1", "pkg2", "__init__.py"), "w") |
||
603 | pkg2_init.write(ns_str) |
||
604 | pkg2_init.close() |
||
605 | import pkg1 |
||
606 | self.assertTrue("pkg1" in pkg_resources._namespace_packages.keys()) |
||
607 | try:
|
||
608 | import pkg1.pkg2 |
||
609 | except ImportError, e: |
||
610 | self.fail("Distribute tried to import the parent namespace package") |
||
611 | # check the _namespace_packages dict
|
||
612 | self.assertTrue("pkg1.pkg2" in pkg_resources._namespace_packages.keys()) |
||
613 | self.assertEqual(pkg_resources._namespace_packages["pkg1"], ["pkg1.pkg2"]) |
||
614 | # check the __path__ attribute contains both paths
|
||
615 | self.assertEqual(pkg1.pkg2.__path__, [
|
||
616 | os.path.join(self._tmpdir, "site-pkgs", "pkg1", "pkg2"), |
||
617 | os.path.join(self._tmpdir, "site-pkgs2", "pkg1", "pkg2") ]) |