commit | author | age
|
f52759
|
1 |
# -*- coding: utf-8 -*- |
8b2c67
|
2 |
import unittest |
CM |
3 |
|
b60bdb
|
4 |
from pyramid.testing import cleanUp |
118ea0
|
5 |
|
0c29cf
|
6 |
from pyramid.compat import text_, native_, text_type, url_quote, PY2 |
MM |
7 |
|
8f8869
|
8 |
|
e6e0ea
|
9 |
class TraversalPathTests(unittest.TestCase): |
eb6afe
|
10 |
def _callFUT(self, path): |
b60bdb
|
11 |
from pyramid.traversal import traversal_path |
0c29cf
|
12 |
|
e6e0ea
|
13 |
return traversal_path(path) |
51c305
|
14 |
|
f84147
|
15 |
def test_utf8(self): |
CM |
16 |
la = b'La Pe\xc3\xb1a' |
|
17 |
encoded = url_quote(la) |
|
18 |
decoded = text_(la, 'utf-8') |
|
19 |
path = '/'.join([encoded, encoded]) |
|
20 |
result = self._callFUT(path) |
|
21 |
self.assertEqual(result, (decoded, decoded)) |
|
22 |
|
|
23 |
def test_utf16(self): |
|
24 |
from pyramid.exceptions import URLDecodeError |
0c29cf
|
25 |
|
f84147
|
26 |
la = text_(b'La Pe\xc3\xb1a', 'utf-8').encode('utf-16') |
CM |
27 |
encoded = url_quote(la) |
|
28 |
path = '/'.join([encoded, encoded]) |
|
29 |
self.assertRaises(URLDecodeError, self._callFUT, path) |
|
30 |
|
|
31 |
def test_unicode_highorder_chars(self): |
|
32 |
path = text_('/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF') |
0c29cf
|
33 |
self.assertEqual( |
MM |
34 |
self._callFUT(path), |
|
35 |
(text_('\u6d41\u884c\u8d8b\u52bf', 'unicode_escape'),), |
|
36 |
) |
f84147
|
37 |
|
CM |
38 |
def test_element_urllquoted(self): |
0c29cf
|
39 |
self.assertEqual( |
MM |
40 |
self._callFUT('/foo/space%20thing/bar'), |
|
41 |
(text_('foo'), text_('space thing'), text_('bar')), |
|
42 |
) |
f84147
|
43 |
|
CM |
44 |
def test_unicode_undecodeable_to_ascii(self): |
|
45 |
path = text_(b'/La Pe\xc3\xb1a', 'utf-8') |
|
46 |
self.assertRaises(UnicodeEncodeError, self._callFUT, path) |
|
47 |
|
0c29cf
|
48 |
|
f84147
|
49 |
class TraversalPathInfoTests(unittest.TestCase): |
CM |
50 |
def _callFUT(self, path): |
|
51 |
from pyramid.traversal import traversal_path_info |
0c29cf
|
52 |
|
f84147
|
53 |
return traversal_path_info(path) |
CM |
54 |
|
dc16fa
|
55 |
def test_path_startswith_endswith(self): |
e6c2d2
|
56 |
self.assertEqual(self._callFUT('/foo/'), (text_('foo'),)) |
8b2c67
|
57 |
|
dc16fa
|
58 |
def test_empty_elements(self): |
e6c2d2
|
59 |
self.assertEqual(self._callFUT('foo///'), (text_('foo'),)) |
8b2c67
|
60 |
|
dc16fa
|
61 |
def test_onedot(self): |
0c29cf
|
62 |
self.assertEqual( |
MM |
63 |
self._callFUT('foo/./bar'), (text_('foo'), text_('bar')) |
|
64 |
) |
8b2c67
|
65 |
|
dc16fa
|
66 |
def test_twodots(self): |
e6c2d2
|
67 |
self.assertEqual(self._callFUT('foo/../bar'), (text_('bar'),)) |
8b2c67
|
68 |
|
f2ef79
|
69 |
def test_twodots_at_start(self): |
e6c2d2
|
70 |
self.assertEqual(self._callFUT('../../bar'), (text_('bar'),)) |
f2ef79
|
71 |
|
dc16fa
|
72 |
def test_segments_are_unicode(self): |
CM |
73 |
result = self._callFUT('/foo/bar') |
8e606d
|
74 |
self.assertEqual(type(result[0]), text_type) |
CM |
75 |
self.assertEqual(type(result[1]), text_type) |
e281fa
|
76 |
|
CM |
77 |
def test_same_value_returned_if_cached(self): |
|
78 |
result1 = self._callFUT('/foo/bar') |
|
79 |
result2 = self._callFUT('/foo/bar') |
e6c2d2
|
80 |
self.assertEqual(result1, (text_('foo'), text_('bar'))) |
CM |
81 |
self.assertEqual(result2, (text_('foo'), text_('bar'))) |
dc16fa
|
82 |
|
841313
|
83 |
def test_unicode_simple(self): |
e6c2d2
|
84 |
path = text_('/abc') |
CM |
85 |
self.assertEqual(self._callFUT(path), (text_('abc'),)) |
841313
|
86 |
|
f84147
|
87 |
def test_highorder(self): |
CM |
88 |
la = b'La Pe\xc3\xb1a' |
|
89 |
latin1 = native_(la) |
|
90 |
result = self._callFUT(latin1) |
|
91 |
self.assertEqual(result, (text_(la, 'utf-8'),)) |
|
92 |
|
|
93 |
def test_highorder_undecodeable(self): |
|
94 |
from pyramid.exceptions import URLDecodeError |
0c29cf
|
95 |
|
f84147
|
96 |
la = text_(b'La Pe\xc3\xb1a', 'utf-8') |
CM |
97 |
notlatin1 = native_(la) |
|
98 |
self.assertRaises(URLDecodeError, self._callFUT, notlatin1) |
0c29cf
|
99 |
|
841313
|
100 |
|
92c3e5
|
101 |
class ResourceTreeTraverserTests(unittest.TestCase): |
8f8869
|
102 |
def setUp(self): |
ed2d14
|
103 |
cleanUp() |
8f8869
|
104 |
|
CM |
105 |
def tearDown(self): |
ed2d14
|
106 |
cleanUp() |
916f88
|
107 |
|
8b2c67
|
108 |
def _getTargetClass(self): |
92c3e5
|
109 |
from pyramid.traversal import ResourceTreeTraverser |
0c29cf
|
110 |
|
92c3e5
|
111 |
return ResourceTreeTraverser |
8b2c67
|
112 |
|
CM |
113 |
def _makeOne(self, *arg, **kw): |
|
114 |
klass = self._getTargetClass() |
|
115 |
return klass(*arg, **kw) |
|
116 |
|
281a7a
|
117 |
def _getEnviron(self, **kw): |
CM |
118 |
environ = {} |
|
119 |
environ.update(kw) |
|
120 |
return environ |
|
121 |
|
8392d7
|
122 |
def test_class_conforms_to_ITraverser(self): |
8b2c67
|
123 |
from zope.interface.verify import verifyClass |
b60bdb
|
124 |
from pyramid.interfaces import ITraverser |
0c29cf
|
125 |
|
4df575
|
126 |
verifyClass(ITraverser, self._getTargetClass()) |
8b2c67
|
127 |
|
8392d7
|
128 |
def test_instance_conforms_to_ITraverser(self): |
8b2c67
|
129 |
from zope.interface.verify import verifyObject |
b60bdb
|
130 |
from pyramid.interfaces import ITraverser |
0c29cf
|
131 |
|
7de404
|
132 |
context = DummyContext() |
cc5e49
|
133 |
verifyObject(ITraverser, self._makeOne(context)) |
8b2c67
|
134 |
|
27d874
|
135 |
def test_call_with_empty_pathinfo(self): |
de4969
|
136 |
policy = self._makeOne(None) |
CM |
137 |
environ = self._getEnviron() |
27d874
|
138 |
request = DummyRequest(environ, path_info='') |
CM |
139 |
result = policy(request) |
|
140 |
self.assertEqual(result['context'], None) |
|
141 |
self.assertEqual(result['view_name'], '') |
|
142 |
self.assertEqual(result['subpath'], ()) |
|
143 |
self.assertEqual(result['traversed'], ()) |
|
144 |
self.assertEqual(result['root'], policy.root) |
|
145 |
self.assertEqual(result['virtual_root'], policy.root) |
|
146 |
self.assertEqual(result['virtual_root_path'], ()) |
|
147 |
|
|
148 |
def test_call_with_pathinfo_KeyError(self): |
|
149 |
policy = self._makeOne(None) |
|
150 |
environ = self._getEnviron() |
|
151 |
request = DummyRequest(environ, toraise=KeyError) |
f426e5
|
152 |
result = policy(request) |
916f88
|
153 |
self.assertEqual(result['context'], None) |
CM |
154 |
self.assertEqual(result['view_name'], '') |
6ecdbc
|
155 |
self.assertEqual(result['subpath'], ()) |
1cd598
|
156 |
self.assertEqual(result['traversed'], ()) |
92dcb5
|
157 |
self.assertEqual(result['root'], policy.root) |
CM |
158 |
self.assertEqual(result['virtual_root'], policy.root) |
|
159 |
self.assertEqual(result['virtual_root_path'], ()) |
|
160 |
|
|
161 |
def test_call_with_pathinfo_highorder(self): |
def68d
|
162 |
path = text_(b'/Qu\xc3\xa9bec', 'utf-8') |
CM |
163 |
foo = DummyContext(None, path) |
92dcb5
|
164 |
root = DummyContext(foo, 'root') |
CM |
165 |
policy = self._makeOne(root) |
def68d
|
166 |
environ = self._getEnviron() |
CM |
167 |
request = DummyRequest(environ, path_info=path) |
92dcb5
|
168 |
result = policy(request) |
CM |
169 |
self.assertEqual(result['context'], foo) |
|
170 |
self.assertEqual(result['view_name'], '') |
|
171 |
self.assertEqual(result['subpath'], ()) |
def68d
|
172 |
self.assertEqual(result['traversed'], (path[1:],)) |
7fc6a3
|
173 |
self.assertEqual(result['root'], policy.root) |
916f88
|
174 |
self.assertEqual(result['virtual_root'], policy.root) |
1cd598
|
175 |
self.assertEqual(result['virtual_root_path'], ()) |
de4969
|
176 |
|
7de404
|
177 |
def test_call_pathel_with_no_getitem(self): |
cc5e49
|
178 |
policy = self._makeOne(None) |
def68d
|
179 |
environ = self._getEnviron() |
ebcdc7
|
180 |
request = DummyRequest(environ, path_info=text_('/foo/bar')) |
f426e5
|
181 |
result = policy(request) |
916f88
|
182 |
self.assertEqual(result['context'], None) |
CM |
183 |
self.assertEqual(result['view_name'], 'foo') |
6ecdbc
|
184 |
self.assertEqual(result['subpath'], ('bar',)) |
1cd598
|
185 |
self.assertEqual(result['traversed'], ()) |
7fc6a3
|
186 |
self.assertEqual(result['root'], policy.root) |
916f88
|
187 |
self.assertEqual(result['virtual_root'], policy.root) |
1cd598
|
188 |
self.assertEqual(result['virtual_root_path'], ()) |
8b2c67
|
189 |
|
CM |
190 |
def test_call_withconn_getitem_emptypath_nosubpath(self): |
7de404
|
191 |
root = DummyContext() |
cc5e49
|
192 |
policy = self._makeOne(root) |
def68d
|
193 |
environ = self._getEnviron() |
ebcdc7
|
194 |
request = DummyRequest(environ, path_info=text_('')) |
f426e5
|
195 |
result = policy(request) |
916f88
|
196 |
self.assertEqual(result['context'], root) |
CM |
197 |
self.assertEqual(result['view_name'], '') |
6ecdbc
|
198 |
self.assertEqual(result['subpath'], ()) |
1cd598
|
199 |
self.assertEqual(result['traversed'], ()) |
7fc6a3
|
200 |
self.assertEqual(result['root'], root) |
916f88
|
201 |
self.assertEqual(result['virtual_root'], root) |
1cd598
|
202 |
self.assertEqual(result['virtual_root_path'], ()) |
8b2c67
|
203 |
|
CM |
204 |
def test_call_withconn_getitem_withpath_nosubpath(self): |
7de404
|
205 |
foo = DummyContext() |
CM |
206 |
root = DummyContext(foo) |
cc5e49
|
207 |
policy = self._makeOne(root) |
def68d
|
208 |
environ = self._getEnviron() |
ebcdc7
|
209 |
request = DummyRequest(environ, path_info=text_('/foo/bar')) |
f426e5
|
210 |
result = policy(request) |
916f88
|
211 |
self.assertEqual(result['context'], foo) |
CM |
212 |
self.assertEqual(result['view_name'], 'bar') |
6ecdbc
|
213 |
self.assertEqual(result['subpath'], ()) |
e6c2d2
|
214 |
self.assertEqual(result['traversed'], (text_('foo'),)) |
7fc6a3
|
215 |
self.assertEqual(result['root'], root) |
916f88
|
216 |
self.assertEqual(result['virtual_root'], root) |
1cd598
|
217 |
self.assertEqual(result['virtual_root_path'], ()) |
8b2c67
|
218 |
|
CM |
219 |
def test_call_withconn_getitem_withpath_withsubpath(self): |
7de404
|
220 |
foo = DummyContext() |
CM |
221 |
root = DummyContext(foo) |
cc5e49
|
222 |
policy = self._makeOne(root) |
def68d
|
223 |
environ = self._getEnviron() |
ebcdc7
|
224 |
request = DummyRequest(environ, path_info=text_('/foo/bar/baz/buz')) |
f426e5
|
225 |
result = policy(request) |
916f88
|
226 |
self.assertEqual(result['context'], foo) |
CM |
227 |
self.assertEqual(result['view_name'], 'bar') |
6ecdbc
|
228 |
self.assertEqual(result['subpath'], ('baz', 'buz')) |
e6c2d2
|
229 |
self.assertEqual(result['traversed'], (text_('foo'),)) |
7fc6a3
|
230 |
self.assertEqual(result['root'], root) |
916f88
|
231 |
self.assertEqual(result['virtual_root'], root) |
1cd598
|
232 |
self.assertEqual(result['virtual_root_path'], ()) |
8b2c67
|
233 |
|
8823e2
|
234 |
def test_call_with_explicit_viewname(self): |
CM |
235 |
foo = DummyContext() |
|
236 |
root = DummyContext(foo) |
cc5e49
|
237 |
policy = self._makeOne(root) |
def68d
|
238 |
environ = self._getEnviron() |
ebcdc7
|
239 |
request = DummyRequest(environ, path_info=text_('/@@foo')) |
f426e5
|
240 |
result = policy(request) |
916f88
|
241 |
self.assertEqual(result['context'], root) |
CM |
242 |
self.assertEqual(result['view_name'], 'foo') |
6ecdbc
|
243 |
self.assertEqual(result['subpath'], ()) |
1cd598
|
244 |
self.assertEqual(result['traversed'], ()) |
7fc6a3
|
245 |
self.assertEqual(result['root'], root) |
916f88
|
246 |
self.assertEqual(result['virtual_root'], root) |
1cd598
|
247 |
self.assertEqual(result['virtual_root_path'], ()) |
8823e2
|
248 |
|
65f3f8
|
249 |
def test_call_with_vh_root(self): |
def68d
|
250 |
environ = self._getEnviron(HTTP_X_VHM_ROOT='/foo/bar') |
7fc6a3
|
251 |
baz = DummyContext(None, 'baz') |
CM |
252 |
bar = DummyContext(baz, 'bar') |
|
253 |
foo = DummyContext(bar, 'foo') |
|
254 |
root = DummyContext(foo, 'root') |
65f3f8
|
255 |
policy = self._makeOne(root) |
ebcdc7
|
256 |
request = DummyRequest(environ, path_info=text_('/baz')) |
f426e5
|
257 |
result = policy(request) |
916f88
|
258 |
self.assertEqual(result['context'], baz) |
CM |
259 |
self.assertEqual(result['view_name'], '') |
6ecdbc
|
260 |
self.assertEqual(result['subpath'], ()) |
0c29cf
|
261 |
self.assertEqual( |
MM |
262 |
result['traversed'], (text_('foo'), text_('bar'), text_('baz')) |
|
263 |
) |
7fc6a3
|
264 |
self.assertEqual(result['root'], root) |
916f88
|
265 |
self.assertEqual(result['virtual_root'], bar) |
0c29cf
|
266 |
self.assertEqual( |
MM |
267 |
result['virtual_root_path'], (text_('foo'), text_('bar')) |
|
268 |
) |
1cd598
|
269 |
|
CM |
270 |
def test_call_with_vh_root2(self): |
def68d
|
271 |
environ = self._getEnviron(HTTP_X_VHM_ROOT='/foo') |
7fc6a3
|
272 |
baz = DummyContext(None, 'baz') |
CM |
273 |
bar = DummyContext(baz, 'bar') |
|
274 |
foo = DummyContext(bar, 'foo') |
|
275 |
root = DummyContext(foo, 'root') |
1cd598
|
276 |
policy = self._makeOne(root) |
ebcdc7
|
277 |
request = DummyRequest(environ, path_info=text_('/bar/baz')) |
f426e5
|
278 |
result = policy(request) |
1cd598
|
279 |
self.assertEqual(result['context'], baz) |
CM |
280 |
self.assertEqual(result['view_name'], '') |
|
281 |
self.assertEqual(result['subpath'], ()) |
0c29cf
|
282 |
self.assertEqual( |
MM |
283 |
result['traversed'], (text_('foo'), text_('bar'), text_('baz')) |
|
284 |
) |
7fc6a3
|
285 |
self.assertEqual(result['root'], root) |
1cd598
|
286 |
self.assertEqual(result['virtual_root'], foo) |
e6c2d2
|
287 |
self.assertEqual(result['virtual_root_path'], (text_('foo'),)) |
1cd598
|
288 |
|
CM |
289 |
def test_call_with_vh_root3(self): |
def68d
|
290 |
environ = self._getEnviron(HTTP_X_VHM_ROOT='/') |
1cd598
|
291 |
baz = DummyContext() |
CM |
292 |
bar = DummyContext(baz) |
|
293 |
foo = DummyContext(bar) |
|
294 |
root = DummyContext(foo) |
|
295 |
policy = self._makeOne(root) |
ebcdc7
|
296 |
request = DummyRequest(environ, path_info=text_('/foo/bar/baz')) |
f426e5
|
297 |
result = policy(request) |
1cd598
|
298 |
self.assertEqual(result['context'], baz) |
CM |
299 |
self.assertEqual(result['view_name'], '') |
|
300 |
self.assertEqual(result['subpath'], ()) |
0c29cf
|
301 |
self.assertEqual( |
MM |
302 |
result['traversed'], (text_('foo'), text_('bar'), text_('baz')) |
|
303 |
) |
7fc6a3
|
304 |
self.assertEqual(result['root'], root) |
1cd598
|
305 |
self.assertEqual(result['virtual_root'], root) |
CM |
306 |
self.assertEqual(result['virtual_root_path'], ()) |
7fc6a3
|
307 |
|
CM |
308 |
def test_call_with_vh_root4(self): |
def68d
|
309 |
environ = self._getEnviron(HTTP_X_VHM_ROOT='/foo/bar/baz') |
7fc6a3
|
310 |
baz = DummyContext(None, 'baz') |
CM |
311 |
bar = DummyContext(baz, 'bar') |
|
312 |
foo = DummyContext(bar, 'foo') |
|
313 |
root = DummyContext(foo, 'root') |
|
314 |
policy = self._makeOne(root) |
ebcdc7
|
315 |
request = DummyRequest(environ, path_info=text_('/')) |
f426e5
|
316 |
result = policy(request) |
7fc6a3
|
317 |
self.assertEqual(result['context'], baz) |
CM |
318 |
self.assertEqual(result['view_name'], '') |
|
319 |
self.assertEqual(result['subpath'], ()) |
0c29cf
|
320 |
self.assertEqual( |
MM |
321 |
result['traversed'], (text_('foo'), text_('bar'), text_('baz')) |
|
322 |
) |
7fc6a3
|
323 |
self.assertEqual(result['root'], root) |
CM |
324 |
self.assertEqual(result['virtual_root'], baz) |
0c29cf
|
325 |
self.assertEqual( |
MM |
326 |
result['virtual_root_path'], |
|
327 |
(text_('foo'), text_('bar'), text_('baz')), |
|
328 |
) |
1cd598
|
329 |
|
CM |
330 |
def test_call_with_vh_root_path_root(self): |
|
331 |
policy = self._makeOne(None) |
def68d
|
332 |
environ = self._getEnviron(HTTP_X_VHM_ROOT='/') |
ebcdc7
|
333 |
request = DummyRequest(environ, path_info=text_('/')) |
f426e5
|
334 |
result = policy(request) |
1cd598
|
335 |
self.assertEqual(result['context'], None) |
CM |
336 |
self.assertEqual(result['view_name'], '') |
|
337 |
self.assertEqual(result['subpath'], ()) |
|
338 |
self.assertEqual(result['traversed'], ()) |
7fc6a3
|
339 |
self.assertEqual(result['root'], policy.root) |
1cd598
|
340 |
self.assertEqual(result['virtual_root'], policy.root) |
CM |
341 |
self.assertEqual(result['virtual_root_path'], ()) |
65f3f8
|
342 |
|
92dcb5
|
343 |
def test_call_with_vh_root_highorder(self): |
def68d
|
344 |
path = text_(b'Qu\xc3\xa9bec', 'utf-8') |
92dcb5
|
345 |
bar = DummyContext(None, 'bar') |
def68d
|
346 |
foo = DummyContext(bar, path) |
92dcb5
|
347 |
root = DummyContext(foo, 'root') |
CM |
348 |
policy = self._makeOne(root) |
bc37a5
|
349 |
if PY2: |
92dcb5
|
350 |
vhm_root = b'/Qu\xc3\xa9bec' |
bc37a5
|
351 |
else: |
MM |
352 |
vhm_root = b'/Qu\xc3\xa9bec'.decode('latin-1') |
def68d
|
353 |
environ = self._getEnviron(HTTP_X_VHM_ROOT=vhm_root) |
ebcdc7
|
354 |
request = DummyRequest(environ, path_info=text_('/bar')) |
92dcb5
|
355 |
result = policy(request) |
CM |
356 |
self.assertEqual(result['context'], bar) |
|
357 |
self.assertEqual(result['view_name'], '') |
|
358 |
self.assertEqual(result['subpath'], ()) |
0c29cf
|
359 |
self.assertEqual(result['traversed'], (path, text_('bar'))) |
92dcb5
|
360 |
self.assertEqual(result['root'], policy.root) |
CM |
361 |
self.assertEqual(result['virtual_root'], foo) |
0c29cf
|
362 |
self.assertEqual(result['virtual_root_path'], (path,)) |
92dcb5
|
363 |
|
def68d
|
364 |
def test_path_info_raises_unicodedecodeerror(self): |
f84147
|
365 |
from pyramid.exceptions import URLDecodeError |
0c29cf
|
366 |
|
217070
|
367 |
foo = DummyContext() |
TS |
368 |
root = DummyContext(foo) |
|
369 |
policy = self._makeOne(root) |
def68d
|
370 |
environ = self._getEnviron() |
ebcdc7
|
371 |
toraise = UnicodeDecodeError('ascii', b'a', 2, 3, '5') |
def68d
|
372 |
request = DummyRequest(environ, toraise=toraise) |
CM |
373 |
request.matchdict = None |
f84147
|
374 |
self.assertRaises(URLDecodeError, policy, request) |
217070
|
375 |
|
dfc2b6
|
376 |
def test_withroute_nothingfancy(self): |
92c3e5
|
377 |
resource = DummyContext() |
CM |
378 |
traverser = self._makeOne(resource) |
def68d
|
379 |
request = DummyRequest({}) |
CM |
380 |
request.matchdict = {} |
f426e5
|
381 |
result = traverser(request) |
92c3e5
|
382 |
self.assertEqual(result['context'], resource) |
dfc2b6
|
383 |
self.assertEqual(result['view_name'], '') |
6ecdbc
|
384 |
self.assertEqual(result['subpath'], ()) |
1cd598
|
385 |
self.assertEqual(result['traversed'], ()) |
92c3e5
|
386 |
self.assertEqual(result['root'], resource) |
CM |
387 |
self.assertEqual(result['virtual_root'], resource) |
1cd598
|
388 |
self.assertEqual(result['virtual_root_path'], ()) |
dfc2b6
|
389 |
|
25cbe1
|
390 |
def test_withroute_with_subpath_string(self): |
92c3e5
|
391 |
resource = DummyContext() |
CM |
392 |
traverser = self._makeOne(resource) |
0c29cf
|
393 |
matchdict = {'subpath': '/a/b/c'} |
def68d
|
394 |
request = DummyRequest({}) |
CM |
395 |
request.matchdict = matchdict |
f426e5
|
396 |
result = traverser(request) |
92c3e5
|
397 |
self.assertEqual(result['context'], resource) |
dfc2b6
|
398 |
self.assertEqual(result['view_name'], '') |
0c29cf
|
399 |
self.assertEqual(result['subpath'], ('a', 'b', 'c')) |
1cd598
|
400 |
self.assertEqual(result['traversed'], ()) |
92c3e5
|
401 |
self.assertEqual(result['root'], resource) |
CM |
402 |
self.assertEqual(result['virtual_root'], resource) |
1cd598
|
403 |
self.assertEqual(result['virtual_root_path'], ()) |
dfc2b6
|
404 |
|
25cbe1
|
405 |
def test_withroute_with_subpath_tuple(self): |
92c3e5
|
406 |
resource = DummyContext() |
CM |
407 |
traverser = self._makeOne(resource) |
0c29cf
|
408 |
matchdict = {'subpath': ('a', 'b', 'c')} |
def68d
|
409 |
request = DummyRequest({}) |
CM |
410 |
request.matchdict = matchdict |
f426e5
|
411 |
result = traverser(request) |
92c3e5
|
412 |
self.assertEqual(result['context'], resource) |
25cbe1
|
413 |
self.assertEqual(result['view_name'], '') |
0c29cf
|
414 |
self.assertEqual(result['subpath'], ('a', 'b', 'c')) |
25cbe1
|
415 |
self.assertEqual(result['traversed'], ()) |
92c3e5
|
416 |
self.assertEqual(result['root'], resource) |
CM |
417 |
self.assertEqual(result['virtual_root'], resource) |
25cbe1
|
418 |
self.assertEqual(result['virtual_root_path'], ()) |
CM |
419 |
|
|
420 |
def test_withroute_and_traverse_string(self): |
92c3e5
|
421 |
resource = DummyContext() |
CM |
422 |
traverser = self._makeOne(resource) |
0c29cf
|
423 |
matchdict = {'traverse': text_('foo/bar')} |
def68d
|
424 |
request = DummyRequest({}) |
CM |
425 |
request.matchdict = matchdict |
f426e5
|
426 |
result = traverser(request) |
92c3e5
|
427 |
self.assertEqual(result['context'], resource) |
dfc2b6
|
428 |
self.assertEqual(result['view_name'], 'foo') |
6ecdbc
|
429 |
self.assertEqual(result['subpath'], ('bar',)) |
1cd598
|
430 |
self.assertEqual(result['traversed'], ()) |
92c3e5
|
431 |
self.assertEqual(result['root'], resource) |
CM |
432 |
self.assertEqual(result['virtual_root'], resource) |
1cd598
|
433 |
self.assertEqual(result['virtual_root_path'], ()) |
dfc2b6
|
434 |
|
25cbe1
|
435 |
def test_withroute_and_traverse_tuple(self): |
92c3e5
|
436 |
resource = DummyContext() |
CM |
437 |
traverser = self._makeOne(resource) |
0c29cf
|
438 |
matchdict = {'traverse': ('foo', 'bar')} |
def68d
|
439 |
request = DummyRequest({}) |
CM |
440 |
request.matchdict = matchdict |
f426e5
|
441 |
result = traverser(request) |
92c3e5
|
442 |
self.assertEqual(result['context'], resource) |
25cbe1
|
443 |
self.assertEqual(result['view_name'], 'foo') |
CM |
444 |
self.assertEqual(result['subpath'], ('bar',)) |
|
445 |
self.assertEqual(result['traversed'], ()) |
92c3e5
|
446 |
self.assertEqual(result['root'], resource) |
CM |
447 |
self.assertEqual(result['virtual_root'], resource) |
25cbe1
|
448 |
self.assertEqual(result['virtual_root_path'], ()) |
CM |
449 |
|
1db5c4
|
450 |
def test_withroute_and_traverse_empty(self): |
CM |
451 |
resource = DummyContext() |
|
452 |
traverser = self._makeOne(resource) |
0c29cf
|
453 |
matchdict = {'traverse': ''} |
def68d
|
454 |
request = DummyRequest({}) |
CM |
455 |
request.matchdict = matchdict |
f426e5
|
456 |
result = traverser(request) |
1db5c4
|
457 |
self.assertEqual(result['context'], resource) |
CM |
458 |
self.assertEqual(result['view_name'], '') |
|
459 |
self.assertEqual(result['subpath'], ()) |
|
460 |
self.assertEqual(result['traversed'], ()) |
|
461 |
self.assertEqual(result['root'], resource) |
|
462 |
self.assertEqual(result['virtual_root'], resource) |
|
463 |
self.assertEqual(result['virtual_root_path'], ()) |
f426e5
|
464 |
|
ece96f
|
465 |
def test_withroute_and_traverse_and_vroot(self): |
CM |
466 |
abc = DummyContext() |
|
467 |
resource = DummyContext(next=abc) |
|
468 |
environ = self._getEnviron(HTTP_X_VHM_ROOT='/abc') |
|
469 |
request = DummyRequest(environ) |
|
470 |
traverser = self._makeOne(resource) |
0c29cf
|
471 |
matchdict = {'traverse': text_('/foo/bar')} |
ece96f
|
472 |
request.matchdict = matchdict |
CM |
473 |
result = traverser(request) |
|
474 |
self.assertEqual(result['context'], abc) |
|
475 |
self.assertEqual(result['view_name'], 'foo') |
|
476 |
self.assertEqual(result['subpath'], ('bar',)) |
|
477 |
self.assertEqual(result['traversed'], ('abc', 'foo')) |
|
478 |
self.assertEqual(result['root'], resource) |
|
479 |
self.assertEqual(result['virtual_root'], abc) |
|
480 |
self.assertEqual(result['virtual_root_path'], ('abc',)) |
0c29cf
|
481 |
|
MM |
482 |
|
bb5d64
|
483 |
class FindInterfaceTests(unittest.TestCase): |
eb6afe
|
484 |
def _callFUT(self, context, iface): |
b60bdb
|
485 |
from pyramid.traversal import find_interface |
0c29cf
|
486 |
|
eb6afe
|
487 |
return find_interface(context, iface) |
bb5d64
|
488 |
|
0f5d8b
|
489 |
def test_it_interface(self): |
bb5d64
|
490 |
baz = DummyContext() |
CM |
491 |
bar = DummyContext(baz) |
|
492 |
foo = DummyContext(bar) |
|
493 |
root = DummyContext(foo) |
|
494 |
root.__parent__ = None |
|
495 |
root.__name__ = 'root' |
|
496 |
foo.__parent__ = root |
|
497 |
foo.__name__ = 'foo' |
|
498 |
bar.__parent__ = foo |
|
499 |
bar.__name__ = 'bar' |
|
500 |
baz.__parent__ = bar |
|
501 |
baz.__name__ = 'baz' |
|
502 |
from zope.interface import directlyProvides |
|
503 |
from zope.interface import Interface |
0c29cf
|
504 |
|
bb5d64
|
505 |
class IFoo(Interface): |
CM |
506 |
pass |
0c29cf
|
507 |
|
bb5d64
|
508 |
directlyProvides(root, IFoo) |
eb6afe
|
509 |
result = self._callFUT(baz, IFoo) |
bb5d64
|
510 |
self.assertEqual(result.__name__, 'root') |
CM |
511 |
|
0f5d8b
|
512 |
def test_it_class(self): |
CM |
513 |
class DummyRoot(object): |
|
514 |
def __init__(self, child): |
|
515 |
self.child = child |
0c29cf
|
516 |
|
0f5d8b
|
517 |
baz = DummyContext() |
CM |
518 |
bar = DummyContext(baz) |
|
519 |
foo = DummyContext(bar) |
|
520 |
root = DummyRoot(foo) |
|
521 |
root.__parent__ = None |
|
522 |
root.__name__ = 'root' |
|
523 |
foo.__parent__ = root |
|
524 |
foo.__name__ = 'foo' |
|
525 |
bar.__parent__ = foo |
|
526 |
bar.__name__ = 'bar' |
|
527 |
baz.__parent__ = bar |
|
528 |
baz.__name__ = 'baz' |
|
529 |
result = self._callFUT(baz, DummyRoot) |
|
530 |
self.assertEqual(result.__name__, 'root') |
|
531 |
|
0c29cf
|
532 |
|
cc5e49
|
533 |
class FindRootTests(unittest.TestCase): |
eb6afe
|
534 |
def _callFUT(self, context): |
b60bdb
|
535 |
from pyramid.traversal import find_root |
0c29cf
|
536 |
|
eb6afe
|
537 |
return find_root(context) |
cc5e49
|
538 |
|
CM |
539 |
def test_it(self): |
|
540 |
dummy = DummyContext() |
|
541 |
baz = DummyContext() |
|
542 |
baz.__parent__ = dummy |
|
543 |
baz.__name__ = 'baz' |
|
544 |
dummy.__parent__ = None |
|
545 |
dummy.__name__ = None |
eb6afe
|
546 |
result = self._callFUT(baz) |
cc5e49
|
547 |
self.assertEqual(result, dummy) |
CM |
548 |
|
0c29cf
|
549 |
|
92c3e5
|
550 |
class FindResourceTests(unittest.TestCase): |
eb6afe
|
551 |
def _callFUT(self, context, name): |
92c3e5
|
552 |
from pyramid.traversal import find_resource |
0c29cf
|
553 |
|
92c3e5
|
554 |
return find_resource(context, name) |
cc5e49
|
555 |
|
077c3c
|
556 |
def _registerTraverser(self, traverser): |
b60bdb
|
557 |
from pyramid.threadlocal import get_current_registry |
0c29cf
|
558 |
|
6fec21
|
559 |
reg = get_current_registry() |
b60bdb
|
560 |
from pyramid.interfaces import ITraverser |
cc5e49
|
561 |
from zope.interface import Interface |
0c29cf
|
562 |
|
6fec21
|
563 |
reg.registerAdapter(traverser, (Interface,), ITraverser) |
cc5e49
|
564 |
|
dbab77
|
565 |
def test_list(self): |
92c3e5
|
566 |
resource = DummyContext() |
0c29cf
|
567 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
077c3c
|
568 |
self._registerTraverser(traverser) |
92c3e5
|
569 |
result = self._callFUT(resource, ['']) |
CM |
570 |
self.assertEqual(result, resource) |
|
571 |
self.assertEqual(resource.request.environ['PATH_INFO'], '/') |
dbab77
|
572 |
|
CM |
573 |
def test_generator(self): |
92c3e5
|
574 |
resource = DummyContext() |
0c29cf
|
575 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
077c3c
|
576 |
self._registerTraverser(traverser) |
0c29cf
|
577 |
|
dbab77
|
578 |
def foo(): |
CM |
579 |
yield '' |
0c29cf
|
580 |
|
92c3e5
|
581 |
result = self._callFUT(resource, foo()) |
CM |
582 |
self.assertEqual(result, resource) |
|
583 |
self.assertEqual(resource.request.environ['PATH_INFO'], '/') |
dbab77
|
584 |
|
CM |
585 |
def test_self_string_found(self): |
92c3e5
|
586 |
resource = DummyContext() |
0c29cf
|
587 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
077c3c
|
588 |
self._registerTraverser(traverser) |
92c3e5
|
589 |
result = self._callFUT(resource, '') |
CM |
590 |
self.assertEqual(result, resource) |
|
591 |
self.assertEqual(resource.request.environ['PATH_INFO'], '') |
dbab77
|
592 |
|
CM |
593 |
def test_self_tuple_found(self): |
92c3e5
|
594 |
resource = DummyContext() |
0c29cf
|
595 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
077c3c
|
596 |
self._registerTraverser(traverser) |
92c3e5
|
597 |
result = self._callFUT(resource, ()) |
CM |
598 |
self.assertEqual(result, resource) |
|
599 |
self.assertEqual(resource.request.environ['PATH_INFO'], '') |
dbab77
|
600 |
|
CM |
601 |
def test_relative_string_found(self): |
92c3e5
|
602 |
resource = DummyContext() |
cc5e49
|
603 |
baz = DummyContext() |
0c29cf
|
604 |
traverser = make_traverser({'context': baz, 'view_name': ''}) |
077c3c
|
605 |
self._registerTraverser(traverser) |
92c3e5
|
606 |
result = self._callFUT(resource, 'baz') |
cc5e49
|
607 |
self.assertEqual(result, baz) |
92c3e5
|
608 |
self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') |
cc5e49
|
609 |
|
dbab77
|
610 |
def test_relative_tuple_found(self): |
92c3e5
|
611 |
resource = DummyContext() |
dbab77
|
612 |
baz = DummyContext() |
0c29cf
|
613 |
traverser = make_traverser({'context': baz, 'view_name': ''}) |
077c3c
|
614 |
self._registerTraverser(traverser) |
92c3e5
|
615 |
result = self._callFUT(resource, ('baz',)) |
dbab77
|
616 |
self.assertEqual(result, baz) |
92c3e5
|
617 |
self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') |
dbab77
|
618 |
|
CM |
619 |
def test_relative_string_notfound(self): |
92c3e5
|
620 |
resource = DummyContext() |
cc5e49
|
621 |
baz = DummyContext() |
0c29cf
|
622 |
traverser = make_traverser({'context': baz, 'view_name': 'bar'}) |
077c3c
|
623 |
self._registerTraverser(traverser) |
92c3e5
|
624 |
self.assertRaises(KeyError, self._callFUT, resource, 'baz') |
CM |
625 |
self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') |
cc5e49
|
626 |
|
dbab77
|
627 |
def test_relative_tuple_notfound(self): |
92c3e5
|
628 |
resource = DummyContext() |
cc5e49
|
629 |
baz = DummyContext() |
0c29cf
|
630 |
traverser = make_traverser({'context': baz, 'view_name': 'bar'}) |
077c3c
|
631 |
self._registerTraverser(traverser) |
92c3e5
|
632 |
self.assertRaises(KeyError, self._callFUT, resource, ('baz',)) |
CM |
633 |
self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') |
cc5e49
|
634 |
|
dbab77
|
635 |
def test_absolute_string_found(self): |
CM |
636 |
root = DummyContext() |
92c3e5
|
637 |
resource = DummyContext() |
CM |
638 |
resource.__parent__ = root |
|
639 |
resource.__name__ = 'baz' |
0c29cf
|
640 |
traverser = make_traverser({'context': root, 'view_name': ''}) |
077c3c
|
641 |
self._registerTraverser(traverser) |
92c3e5
|
642 |
result = self._callFUT(resource, '/') |
dbab77
|
643 |
self.assertEqual(result, root) |
CM |
644 |
self.assertEqual(root.wascontext, True) |
6fec21
|
645 |
self.assertEqual(root.request.environ['PATH_INFO'], '/') |
cc5e49
|
646 |
|
dbab77
|
647 |
def test_absolute_tuple_found(self): |
CM |
648 |
root = DummyContext() |
92c3e5
|
649 |
resource = DummyContext() |
CM |
650 |
resource.__parent__ = root |
|
651 |
resource.__name__ = 'baz' |
0c29cf
|
652 |
traverser = make_traverser({'context': root, 'view_name': ''}) |
077c3c
|
653 |
self._registerTraverser(traverser) |
92c3e5
|
654 |
result = self._callFUT(resource, ('',)) |
dbab77
|
655 |
self.assertEqual(result, root) |
CM |
656 |
self.assertEqual(root.wascontext, True) |
6fec21
|
657 |
self.assertEqual(root.request.environ['PATH_INFO'], '/') |
dbab77
|
658 |
|
CM |
659 |
def test_absolute_string_notfound(self): |
|
660 |
root = DummyContext() |
92c3e5
|
661 |
resource = DummyContext() |
CM |
662 |
resource.__parent__ = root |
|
663 |
resource.__name__ = 'baz' |
0c29cf
|
664 |
traverser = make_traverser({'context': root, 'view_name': 'fuz'}) |
077c3c
|
665 |
self._registerTraverser(traverser) |
92c3e5
|
666 |
self.assertRaises(KeyError, self._callFUT, resource, '/') |
dbab77
|
667 |
self.assertEqual(root.wascontext, True) |
6fec21
|
668 |
self.assertEqual(root.request.environ['PATH_INFO'], '/') |
dbab77
|
669 |
|
CM |
670 |
def test_absolute_tuple_notfound(self): |
|
671 |
root = DummyContext() |
92c3e5
|
672 |
resource = DummyContext() |
CM |
673 |
resource.__parent__ = root |
|
674 |
resource.__name__ = 'baz' |
0c29cf
|
675 |
traverser = make_traverser({'context': root, 'view_name': 'fuz'}) |
077c3c
|
676 |
self._registerTraverser(traverser) |
92c3e5
|
677 |
self.assertRaises(KeyError, self._callFUT, resource, ('',)) |
dbab77
|
678 |
self.assertEqual(root.wascontext, True) |
6fec21
|
679 |
self.assertEqual(root.request.environ['PATH_INFO'], '/') |
916f88
|
680 |
|
a66593
|
681 |
def test_absolute_unicode_found(self): |
CM |
682 |
# test for bug wiggy found in wild, traceback stack: |
|
683 |
# root = u'/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF' |
92c3e5
|
684 |
# wiggy's code: section=find_resource(page, root) |
CM |
685 |
# find_resource L76: D = traverse(resource, path) |
a66593
|
686 |
# traverse L291: return traverser(request) |
CM |
687 |
# __call__ line 568: vpath_tuple = traversal_path(vpath) |
|
688 |
# lru_cached line 91: f(*arg) |
|
689 |
# traversal_path line 443: path.encode('ascii') |
|
690 |
# UnicodeEncodeError: 'ascii' codec can't encode characters in |
|
691 |
# position 1-12: ordinal not in range(128) |
|
692 |
# |
|
693 |
# solution: encode string to ascii in pyramid.traversal.traverse |
|
694 |
# before passing it along to webob as path_info |
92c3e5
|
695 |
from pyramid.traversal import ResourceTreeTraverser |
0c29cf
|
696 |
|
a66593
|
697 |
unprintable = DummyContext() |
CM |
698 |
root = DummyContext(unprintable) |
|
699 |
unprintable.__parent__ = root |
e6c2d2
|
700 |
unprintable.__name__ = text_( |
0c29cf
|
701 |
b'/\xe6\xb5\x81\xe8\xa1\x8c\xe8\xb6\x8b\xe5\x8a\xbf', 'utf-8' |
MM |
702 |
) |
a66593
|
703 |
root.__parent__ = None |
CM |
704 |
root.__name__ = None |
92c3e5
|
705 |
traverser = ResourceTreeTraverser |
a66593
|
706 |
self._registerTraverser(traverser) |
e6c2d2
|
707 |
result = self._callFUT( |
0c29cf
|
708 |
root, text_(b'/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF') |
MM |
709 |
) |
a66593
|
710 |
self.assertEqual(result, unprintable) |
0c29cf
|
711 |
|
358dc2
|
712 |
|
92c3e5
|
713 |
class ResourcePathTests(unittest.TestCase): |
CM |
714 |
def _callFUT(self, resource, *elements): |
|
715 |
from pyramid.traversal import resource_path |
0c29cf
|
716 |
|
92c3e5
|
717 |
return resource_path(resource, *elements) |
c750ba
|
718 |
|
CM |
719 |
def test_it(self): |
|
720 |
baz = DummyContext() |
|
721 |
bar = DummyContext(baz) |
|
722 |
foo = DummyContext(bar) |
|
723 |
root = DummyContext(foo) |
|
724 |
root.__parent__ = None |
|
725 |
root.__name__ = None |
|
726 |
foo.__parent__ = root |
|
727 |
foo.__name__ = 'foo ' |
|
728 |
bar.__parent__ = foo |
|
729 |
bar.__name__ = 'bar' |
|
730 |
baz.__parent__ = bar |
|
731 |
baz.__name__ = 'baz' |
eb6afe
|
732 |
result = self._callFUT(baz, 'this/theotherthing', 'that') |
a97a70
|
733 |
self.assertEqual(result, '/foo%20/bar/baz/this%2Ftheotherthing/that') |
CM |
734 |
|
|
735 |
def test_root_default(self): |
|
736 |
root = DummyContext() |
|
737 |
root.__parent__ = None |
|
738 |
root.__name__ = None |
|
739 |
result = self._callFUT(root) |
|
740 |
self.assertEqual(result, '/') |
8e037f
|
741 |
|
CM |
742 |
def test_root_default_emptystring(self): |
|
743 |
root = DummyContext() |
|
744 |
root.__parent__ = None |
|
745 |
root.__name__ = '' |
|
746 |
result = self._callFUT(root) |
|
747 |
self.assertEqual(result, '/') |
|
748 |
|
|
749 |
def test_root_object_nonnull_name_direct(self): |
|
750 |
root = DummyContext() |
|
751 |
root.__parent__ = None |
|
752 |
root.__name__ = 'flubadub' |
|
753 |
result = self._callFUT(root) |
0c29cf
|
754 |
self.assertEqual(result, 'flubadub') # insane case |
8e037f
|
755 |
|
CM |
756 |
def test_root_object_nonnull_name_indirect(self): |
|
757 |
root = DummyContext() |
|
758 |
root.__parent__ = None |
|
759 |
root.__name__ = 'flubadub' |
|
760 |
other = DummyContext() |
|
761 |
other.__parent__ = root |
|
762 |
other.__name__ = 'barker' |
|
763 |
result = self._callFUT(other) |
0c29cf
|
764 |
self.assertEqual(result, 'flubadub/barker') # insane case |
8e037f
|
765 |
|
a97a70
|
766 |
def test_nonroot_default(self): |
CM |
767 |
root = DummyContext() |
|
768 |
root.__parent__ = None |
|
769 |
root.__name__ = None |
|
770 |
other = DummyContext() |
|
771 |
other.__parent__ = root |
|
772 |
other.__name__ = 'other' |
|
773 |
result = self._callFUT(other) |
|
774 |
self.assertEqual(result, '/other') |
b1de62
|
775 |
|
CM |
776 |
def test_path_with_None_itermediate_names(self): |
|
777 |
root = DummyContext() |
|
778 |
root.__parent__ = None |
|
779 |
root.__name__ = None |
|
780 |
other = DummyContext() |
|
781 |
other.__parent__ = root |
|
782 |
other.__name__ = None |
|
783 |
other2 = DummyContext() |
|
784 |
other2.__parent__ = other |
|
785 |
other2.__name__ = 'other2' |
|
786 |
result = self._callFUT(other2) |
|
787 |
self.assertEqual(result, '//other2') |
a97a70
|
788 |
|
0c29cf
|
789 |
|
92c3e5
|
790 |
class ResourcePathTupleTests(unittest.TestCase): |
CM |
791 |
def _callFUT(self, resource, *elements): |
|
792 |
from pyramid.traversal import resource_path_tuple |
0c29cf
|
793 |
|
92c3e5
|
794 |
return resource_path_tuple(resource, *elements) |
a97a70
|
795 |
|
CM |
796 |
def test_it(self): |
|
797 |
baz = DummyContext() |
|
798 |
bar = DummyContext(baz) |
|
799 |
foo = DummyContext(bar) |
|
800 |
root = DummyContext(foo) |
|
801 |
root.__parent__ = None |
|
802 |
root.__name__ = None |
|
803 |
foo.__parent__ = root |
|
804 |
foo.__name__ = 'foo ' |
|
805 |
bar.__parent__ = foo |
|
806 |
bar.__name__ = 'bar' |
|
807 |
baz.__parent__ = bar |
|
808 |
baz.__name__ = 'baz' |
|
809 |
result = self._callFUT(baz, 'this/theotherthing', 'that') |
0c29cf
|
810 |
self.assertEqual( |
MM |
811 |
result, ('', 'foo ', 'bar', 'baz', 'this/theotherthing', 'that') |
|
812 |
) |
c750ba
|
813 |
|
eb6afe
|
814 |
def test_root_default(self): |
6d4015
|
815 |
root = DummyContext() |
CM |
816 |
root.__parent__ = None |
|
817 |
root.__name__ = None |
eb6afe
|
818 |
result = self._callFUT(root) |
dbab77
|
819 |
self.assertEqual(result, ('',)) |
51c305
|
820 |
|
1db5c4
|
821 |
def test_root_default_emptystring_name(self): |
CM |
822 |
root = DummyContext() |
|
823 |
root.__parent__ = None |
|
824 |
root.__name__ = '' |
|
825 |
other = DummyContext() |
|
826 |
other.__parent__ = root |
|
827 |
other.__name__ = 'other' |
|
828 |
result = self._callFUT(other) |
0c29cf
|
829 |
self.assertEqual(result, ('', 'other')) |
1db5c4
|
830 |
|
eb6afe
|
831 |
def test_nonroot_default(self): |
CM |
832 |
root = DummyContext() |
|
833 |
root.__parent__ = None |
|
834 |
root.__name__ = None |
|
835 |
other = DummyContext() |
|
836 |
other.__parent__ = root |
|
837 |
other.__name__ = 'other' |
|
838 |
result = self._callFUT(other) |
dbab77
|
839 |
self.assertEqual(result, ('', 'other')) |
c750ba
|
840 |
|
b1de62
|
841 |
def test_path_with_None_itermediate_names(self): |
CM |
842 |
root = DummyContext() |
|
843 |
root.__parent__ = None |
|
844 |
root.__name__ = None |
|
845 |
other = DummyContext() |
|
846 |
other.__parent__ = root |
|
847 |
other.__name__ = None |
|
848 |
other2 = DummyContext() |
|
849 |
other2.__parent__ = other |
|
850 |
other2.__name__ = 'other2' |
|
851 |
result = self._callFUT(other2) |
|
852 |
self.assertEqual(result, ('', '', 'other2')) |
|
853 |
|
0c29cf
|
854 |
|
a97a70
|
855 |
class QuotePathSegmentTests(unittest.TestCase): |
CM |
856 |
def _callFUT(self, s): |
b60bdb
|
857 |
from pyramid.traversal import quote_path_segment |
0c29cf
|
858 |
|
a97a70
|
859 |
return quote_path_segment(s) |
CM |
860 |
|
|
861 |
def test_unicode(self): |
a84e17
|
862 |
la = text_(b'/La Pe\xc3\xb1a', 'utf-8') |
a97a70
|
863 |
result = self._callFUT(la) |
CM |
864 |
self.assertEqual(result, '%2FLa%20Pe%C3%B1a') |
|
865 |
|
|
866 |
def test_string(self): |
|
867 |
s = '/ hello!' |
|
868 |
result = self._callFUT(s) |
f52759
|
869 |
self.assertEqual(result, '%2F%20hello!') |
a97a70
|
870 |
|
fcbd7b
|
871 |
def test_int(self): |
CM |
872 |
s = 12345 |
|
873 |
result = self._callFUT(s) |
|
874 |
self.assertEqual(result, '12345') |
0c29cf
|
875 |
|
fcbd7b
|
876 |
def test_long(self): |
475532
|
877 |
from pyramid.compat import long |
fcbd7b
|
878 |
import sys |
0c29cf
|
879 |
|
a84e17
|
880 |
s = long(sys.maxsize + 1) |
fcbd7b
|
881 |
result = self._callFUT(s) |
CM |
882 |
expected = str(s) |
|
883 |
self.assertEqual(result, expected) |
|
884 |
|
|
885 |
def test_other(self): |
|
886 |
class Foo(object): |
|
887 |
def __str__(self): |
|
888 |
return 'abc' |
0c29cf
|
889 |
|
fcbd7b
|
890 |
s = Foo() |
CM |
891 |
result = self._callFUT(s) |
|
892 |
self.assertEqual(result, 'abc') |
0c29cf
|
893 |
|
fcbd7b
|
894 |
|
118ea0
|
895 |
class ResourceURLTests(unittest.TestCase): |
e62e47
|
896 |
def _makeOne(self, context, url): |
CM |
897 |
return self._getTargetClass()(context, url) |
|
898 |
|
|
899 |
def _getTargetClass(self): |
118ea0
|
900 |
from pyramid.traversal import ResourceURL |
0c29cf
|
901 |
|
118ea0
|
902 |
return ResourceURL |
e62e47
|
903 |
|
118ea0
|
904 |
def test_instance_conforms_to_IResourceURL(self): |
CM |
905 |
from pyramid.interfaces import IResourceURL |
|
906 |
from zope.interface.verify import verifyObject |
0c29cf
|
907 |
|
118ea0
|
908 |
context = DummyContext() |
CM |
909 |
request = DummyRequest() |
|
910 |
verifyObject(IResourceURL, self._makeOne(context, request)) |
bac5b3
|
911 |
|
118ea0
|
912 |
def test_IResourceURL_attributes_with_vroot(self): |
CM |
913 |
from pyramid.interfaces import VH_ROOT_KEY |
0c29cf
|
914 |
|
118ea0
|
915 |
root = DummyContext() |
CM |
916 |
root.__parent__ = None |
|
917 |
root.__name__ = None |
|
918 |
one = DummyContext() |
|
919 |
one.__parent__ = root |
|
920 |
one.__name__ = 'one' |
|
921 |
two = DummyContext() |
|
922 |
two.__parent__ = one |
|
923 |
two.__name__ = 'two' |
0c29cf
|
924 |
environ = {VH_ROOT_KEY: '/one'} |
118ea0
|
925 |
request = DummyRequest(environ) |
CM |
926 |
context_url = self._makeOne(two, request) |
|
927 |
self.assertEqual(context_url.physical_path, '/one/two/') |
|
928 |
self.assertEqual(context_url.virtual_path, '/two/') |
0c29cf
|
929 |
self.assertEqual( |
MM |
930 |
context_url.physical_path_tuple, ('', 'one', 'two', '') |
|
931 |
) |
db0185
|
932 |
self.assertEqual(context_url.virtual_path_tuple, ('', 'two', '')) |
0c29cf
|
933 |
|
db0185
|
934 |
def test_IResourceURL_attributes_vroot_ends_with_slash(self): |
CM |
935 |
from pyramid.interfaces import VH_ROOT_KEY |
0c29cf
|
936 |
|
db0185
|
937 |
root = DummyContext() |
CM |
938 |
root.__parent__ = None |
|
939 |
root.__name__ = None |
|
940 |
one = DummyContext() |
|
941 |
one.__parent__ = root |
|
942 |
one.__name__ = 'one' |
|
943 |
two = DummyContext() |
|
944 |
two.__parent__ = one |
|
945 |
two.__name__ = 'two' |
0c29cf
|
946 |
environ = {VH_ROOT_KEY: '/one/'} |
db0185
|
947 |
request = DummyRequest(environ) |
CM |
948 |
context_url = self._makeOne(two, request) |
|
949 |
self.assertEqual(context_url.physical_path, '/one/two/') |
|
950 |
self.assertEqual(context_url.virtual_path, '/two/') |
0c29cf
|
951 |
self.assertEqual( |
MM |
952 |
context_url.physical_path_tuple, ('', 'one', 'two', '') |
|
953 |
) |
db0185
|
954 |
self.assertEqual(context_url.virtual_path_tuple, ('', 'two', '')) |
0c29cf
|
955 |
|
118ea0
|
956 |
def test_IResourceURL_attributes_no_vroot(self): |
CM |
957 |
root = DummyContext() |
|
958 |
root.__parent__ = None |
|
959 |
root.__name__ = None |
|
960 |
one = DummyContext() |
|
961 |
one.__parent__ = root |
|
962 |
one.__name__ = 'one' |
|
963 |
two = DummyContext() |
|
964 |
two.__parent__ = one |
|
965 |
two.__name__ = 'two' |
|
966 |
environ = {} |
|
967 |
request = DummyRequest(environ) |
|
968 |
context_url = self._makeOne(two, request) |
|
969 |
self.assertEqual(context_url.physical_path, '/one/two/') |
|
970 |
self.assertEqual(context_url.virtual_path, '/one/two/') |
0c29cf
|
971 |
self.assertEqual( |
MM |
972 |
context_url.physical_path_tuple, ('', 'one', 'two', '') |
|
973 |
) |
|
974 |
self.assertEqual( |
|
975 |
context_url.virtual_path_tuple, ('', 'one', 'two', '') |
|
976 |
) |
|
977 |
|
db0185
|
978 |
|
e62e47
|
979 |
class TestVirtualRoot(unittest.TestCase): |
CM |
980 |
def setUp(self): |
|
981 |
cleanUp() |
|
982 |
|
|
983 |
def tearDown(self): |
|
984 |
cleanUp() |
|
985 |
|
92c3e5
|
986 |
def _callFUT(self, resource, request): |
b60bdb
|
987 |
from pyramid.traversal import virtual_root |
0c29cf
|
988 |
|
92c3e5
|
989 |
return virtual_root(resource, request) |
e62e47
|
990 |
|
7ba907
|
991 |
def _registerTraverser(self, traverser): |
MM |
992 |
from pyramid.threadlocal import get_current_registry |
0c29cf
|
993 |
|
7ba907
|
994 |
reg = get_current_registry() |
MM |
995 |
from pyramid.interfaces import ITraverser |
e62e47
|
996 |
from zope.interface import Interface |
0c29cf
|
997 |
|
7ba907
|
998 |
reg.registerAdapter(traverser, (Interface,), ITraverser) |
MM |
999 |
|
|
1000 |
def test_virtual_root_no_virtual_root_path(self): |
|
1001 |
root = DummyContext() |
|
1002 |
root.__name__ = None |
|
1003 |
root.__parent__ = None |
|
1004 |
one = DummyContext() |
|
1005 |
one.__name__ = 'one' |
|
1006 |
one.__parent__ = root |
|
1007 |
request = DummyRequest() |
|
1008 |
result = self._callFUT(one, request) |
|
1009 |
self.assertEqual(result, root) |
|
1010 |
|
|
1011 |
def test_virtual_root_no_virtual_root_path_with_root_on_request(self): |
e62e47
|
1012 |
context = DummyContext() |
7ba907
|
1013 |
context.__parent__ = None |
MM |
1014 |
request = DummyRequest() |
|
1015 |
request.root = DummyContext() |
e62e47
|
1016 |
result = self._callFUT(context, request) |
7ba907
|
1017 |
self.assertEqual(result, request.root) |
MM |
1018 |
|
|
1019 |
def test_virtual_root_with_virtual_root_path(self): |
|
1020 |
from pyramid.interfaces import VH_ROOT_KEY |
0c29cf
|
1021 |
|
7ba907
|
1022 |
root = DummyContext() |
MM |
1023 |
root.__parent__ = None |
|
1024 |
context = DummyContext() |
|
1025 |
context.__name__ = 'one' |
|
1026 |
context.__parent__ = root |
|
1027 |
traversed_to = DummyContext() |
0c29cf
|
1028 |
environ = {VH_ROOT_KEY: '/one'} |
7ba907
|
1029 |
request = DummyRequest(environ) |
0c29cf
|
1030 |
traverser = make_traverser({'context': traversed_to, 'view_name': ''}) |
7ba907
|
1031 |
self._registerTraverser(traverser) |
MM |
1032 |
result = self._callFUT(context, request) |
|
1033 |
self.assertEqual(result, traversed_to) |
|
1034 |
self.assertEqual(root.request.environ['PATH_INFO'], '/one') |
e62e47
|
1035 |
|
160f01
|
1036 |
def test_default(self): |
CM |
1037 |
context = DummyContext() |
6fec21
|
1038 |
request = _makeRequest() |
160f01
|
1039 |
request.environ['PATH_INFO'] = '/' |
CM |
1040 |
result = self._callFUT(context, request) |
|
1041 |
self.assertEqual(result, context) |
|
1042 |
|
45d08c
|
1043 |
def test_default_no_registry_on_request(self): |
CM |
1044 |
context = DummyContext() |
|
1045 |
request = _makeRequest() |
|
1046 |
del request.registry |
|
1047 |
request.environ['PATH_INFO'] = '/' |
|
1048 |
result = self._callFUT(context, request) |
|
1049 |
self.assertEqual(result, context) |
|
1050 |
|
0c29cf
|
1051 |
|
916f88
|
1052 |
class TraverseTests(unittest.TestCase): |
CM |
1053 |
def setUp(self): |
|
1054 |
cleanUp() |
|
1055 |
|
|
1056 |
def tearDown(self): |
|
1057 |
cleanUp() |
|
1058 |
|
|
1059 |
def _callFUT(self, context, name): |
b60bdb
|
1060 |
from pyramid.traversal import traverse |
0c29cf
|
1061 |
|
916f88
|
1062 |
return traverse(context, name) |
CM |
1063 |
|
077c3c
|
1064 |
def _registerTraverser(self, traverser): |
b60bdb
|
1065 |
from pyramid.threadlocal import get_current_registry |
0c29cf
|
1066 |
|
6fec21
|
1067 |
reg = get_current_registry() |
b60bdb
|
1068 |
from pyramid.interfaces import ITraverser |
916f88
|
1069 |
from zope.interface import Interface |
0c29cf
|
1070 |
|
6fec21
|
1071 |
reg.registerAdapter(traverser, (Interface,), ITraverser) |
CM |
1072 |
|
|
1073 |
def test_request_has_registry(self): |
b60bdb
|
1074 |
from pyramid.threadlocal import get_current_registry |
0c29cf
|
1075 |
|
92c3e5
|
1076 |
resource = DummyContext() |
0c29cf
|
1077 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
6fec21
|
1078 |
self._registerTraverser(traverser) |
92c3e5
|
1079 |
self._callFUT(resource, ['']) |
CM |
1080 |
self.assertEqual(resource.request.registry, get_current_registry()) |
916f88
|
1081 |
|
CM |
1082 |
def test_list(self): |
92c3e5
|
1083 |
resource = DummyContext() |
0c29cf
|
1084 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
077c3c
|
1085 |
self._registerTraverser(traverser) |
92c3e5
|
1086 |
self._callFUT(resource, ['']) |
CM |
1087 |
self.assertEqual(resource.request.environ['PATH_INFO'], '/') |
916f88
|
1088 |
|
CM |
1089 |
def test_generator(self): |
92c3e5
|
1090 |
resource = DummyContext() |
0c29cf
|
1091 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
077c3c
|
1092 |
self._registerTraverser(traverser) |
0c29cf
|
1093 |
|
916f88
|
1094 |
def foo(): |
CM |
1095 |
yield '' |
0c29cf
|
1096 |
|
92c3e5
|
1097 |
self._callFUT(resource, foo()) |
CM |
1098 |
self.assertEqual(resource.request.environ['PATH_INFO'], '/') |
916f88
|
1099 |
|
CM |
1100 |
def test_self_string_found(self): |
92c3e5
|
1101 |
resource = DummyContext() |
0c29cf
|
1102 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
077c3c
|
1103 |
self._registerTraverser(traverser) |
92c3e5
|
1104 |
self._callFUT(resource, '') |
CM |
1105 |
self.assertEqual(resource.request.environ['PATH_INFO'], '') |
916f88
|
1106 |
|
f84147
|
1107 |
def test_self_unicode_found(self): |
CM |
1108 |
resource = DummyContext() |
0c29cf
|
1109 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
f84147
|
1110 |
self._registerTraverser(traverser) |
CM |
1111 |
self._callFUT(resource, text_('')) |
|
1112 |
self.assertEqual(resource.request.environ['PATH_INFO'], '') |
|
1113 |
|
916f88
|
1114 |
def test_self_tuple_found(self): |
92c3e5
|
1115 |
resource = DummyContext() |
0c29cf
|
1116 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
077c3c
|
1117 |
self._registerTraverser(traverser) |
92c3e5
|
1118 |
self._callFUT(resource, ()) |
CM |
1119 |
self.assertEqual(resource.request.environ['PATH_INFO'], '') |
916f88
|
1120 |
|
CM |
1121 |
def test_relative_string_found(self): |
92c3e5
|
1122 |
resource = DummyContext() |
916f88
|
1123 |
baz = DummyContext() |
0c29cf
|
1124 |
traverser = make_traverser({'context': baz, 'view_name': ''}) |
077c3c
|
1125 |
self._registerTraverser(traverser) |
92c3e5
|
1126 |
self._callFUT(resource, 'baz') |
CM |
1127 |
self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') |
916f88
|
1128 |
|
CM |
1129 |
def test_relative_tuple_found(self): |
92c3e5
|
1130 |
resource = DummyContext() |
916f88
|
1131 |
baz = DummyContext() |
0c29cf
|
1132 |
traverser = make_traverser({'context': baz, 'view_name': ''}) |
077c3c
|
1133 |
self._registerTraverser(traverser) |
92c3e5
|
1134 |
self._callFUT(resource, ('baz',)) |
CM |
1135 |
self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') |
916f88
|
1136 |
|
CM |
1137 |
def test_absolute_string_found(self): |
|
1138 |
root = DummyContext() |
92c3e5
|
1139 |
resource = DummyContext() |
CM |
1140 |
resource.__parent__ = root |
|
1141 |
resource.__name__ = 'baz' |
0c29cf
|
1142 |
traverser = make_traverser({'context': root, 'view_name': ''}) |
077c3c
|
1143 |
self._registerTraverser(traverser) |
92c3e5
|
1144 |
self._callFUT(resource, '/') |
916f88
|
1145 |
self.assertEqual(root.wascontext, True) |
6fec21
|
1146 |
self.assertEqual(root.request.environ['PATH_INFO'], '/') |
916f88
|
1147 |
|
CM |
1148 |
def test_absolute_tuple_found(self): |
|
1149 |
root = DummyContext() |
92c3e5
|
1150 |
resource = DummyContext() |
CM |
1151 |
resource.__parent__ = root |
|
1152 |
resource.__name__ = 'baz' |
0c29cf
|
1153 |
traverser = make_traverser({'context': root, 'view_name': ''}) |
077c3c
|
1154 |
self._registerTraverser(traverser) |
92c3e5
|
1155 |
self._callFUT(resource, ('',)) |
916f88
|
1156 |
self.assertEqual(root.wascontext, True) |
6fec21
|
1157 |
self.assertEqual(root.request.environ['PATH_INFO'], '/') |
916f88
|
1158 |
|
391afe
|
1159 |
def test_empty_sequence(self): |
CM |
1160 |
root = DummyContext() |
92c3e5
|
1161 |
resource = DummyContext() |
CM |
1162 |
resource.__parent__ = root |
|
1163 |
resource.__name__ = 'baz' |
0c29cf
|
1164 |
traverser = make_traverser({'context': root, 'view_name': ''}) |
077c3c
|
1165 |
self._registerTraverser(traverser) |
92c3e5
|
1166 |
self._callFUT(resource, []) |
CM |
1167 |
self.assertEqual(resource.wascontext, True) |
|
1168 |
self.assertEqual(resource.request.environ['PATH_INFO'], '') |
391afe
|
1169 |
|
164677
|
1170 |
def test_default_traverser(self): |
92c3e5
|
1171 |
resource = DummyContext() |
CM |
1172 |
result = self._callFUT(resource, '') |
e46105
|
1173 |
self.assertEqual(result['view_name'], '') |
92c3e5
|
1174 |
self.assertEqual(result['context'], resource) |
c32af0
|
1175 |
|
81a833
|
1176 |
def test_requestfactory_overridden(self): |
b60bdb
|
1177 |
from pyramid.interfaces import IRequestFactory |
CM |
1178 |
from pyramid.request import Request |
|
1179 |
from pyramid.threadlocal import get_current_registry |
0c29cf
|
1180 |
|
81a833
|
1181 |
reg = get_current_registry() |
0c29cf
|
1182 |
|
81a833
|
1183 |
class MyRequest(Request): |
CM |
1184 |
pass |
0c29cf
|
1185 |
|
81a833
|
1186 |
reg.registerUtility(MyRequest, IRequestFactory) |
92c3e5
|
1187 |
resource = DummyContext() |
0c29cf
|
1188 |
traverser = make_traverser({'context': resource, 'view_name': ''}) |
81a833
|
1189 |
self._registerTraverser(traverser) |
92c3e5
|
1190 |
self._callFUT(resource, ['']) |
CM |
1191 |
self.assertEqual(resource.request.__class__, MyRequest) |
81a833
|
1192 |
|
0c29cf
|
1193 |
|
eac7c4
|
1194 |
class TestDefaultRootFactory(unittest.TestCase): |
CM |
1195 |
def _getTargetClass(self): |
b60bdb
|
1196 |
from pyramid.traversal import DefaultRootFactory |
0c29cf
|
1197 |
|
eac7c4
|
1198 |
return DefaultRootFactory |
CM |
1199 |
|
|
1200 |
def _makeOne(self, environ): |
|
1201 |
return self._getTargetClass()(environ) |
|
1202 |
|
95e971
|
1203 |
def test_it(self): |
CM |
1204 |
class DummyRequest(object): |
|
1205 |
pass |
0c29cf
|
1206 |
|
51c305
|
1207 |
root = self._makeOne(DummyRequest()) |
eac7c4
|
1208 |
self.assertEqual(root.__parent__, None) |
CM |
1209 |
self.assertEqual(root.__name__, None) |
|
1210 |
|
0c29cf
|
1211 |
|
1db5c4
|
1212 |
class Test__join_path_tuple(unittest.TestCase): |
CM |
1213 |
def _callFUT(self, tup): |
|
1214 |
from pyramid.traversal import _join_path_tuple |
0c29cf
|
1215 |
|
1db5c4
|
1216 |
return _join_path_tuple(tup) |
CM |
1217 |
|
|
1218 |
def test_empty_tuple(self): |
|
1219 |
# tests "or '/'" case |
|
1220 |
result = self._callFUT(()) |
|
1221 |
self.assertEqual(result, '/') |
|
1222 |
|
|
1223 |
def test_nonempty_tuple(self): |
|
1224 |
result = self._callFUT(('x',)) |
|
1225 |
self.assertEqual(result, 'x') |
eac7c4
|
1226 |
|
f52759
|
1227 |
def test_segments_with_unsafes(self): |
0c29cf
|
1228 |
safe_segments = tuple( |
10ddb6
|
1229 |
u"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" |
MM |
1230 |
u"-._~!$&'()*+,;=:@" |
0c29cf
|
1231 |
) |
f52759
|
1232 |
result = self._callFUT(safe_segments) |
MK |
1233 |
self.assertEqual(result, u'/'.join(safe_segments)) |
0c29cf
|
1234 |
unsafe_segments = tuple( |
MM |
1235 |
chr(i) for i in range(0x20, 0x80) if not chr(i) in safe_segments |
|
1236 |
) + (u'あ',) |
f52759
|
1237 |
result = self._callFUT(unsafe_segments) |
0c29cf
|
1238 |
self.assertEqual( |
MM |
1239 |
result, |
|
1240 |
u'/'.join( |
|
1241 |
''.join( |
|
1242 |
'%%%02X' % (ord(c) if isinstance(c, str) else c) |
|
1243 |
for c in unsafe_segment.encode('utf-8') |
|
1244 |
) |
|
1245 |
for unsafe_segment in unsafe_segments |
|
1246 |
), |
|
1247 |
) |
f52759
|
1248 |
|
MK |
1249 |
|
916f88
|
1250 |
def make_traverser(result): |
cc5e49
|
1251 |
class DummyTraverser(object): |
CM |
1252 |
def __init__(self, context): |
358dc2
|
1253 |
self.context = context |
cc5e49
|
1254 |
context.wascontext = True |
0c29cf
|
1255 |
|
6fec21
|
1256 |
def __call__(self, request): |
CM |
1257 |
self.context.request = request |
916f88
|
1258 |
return result |
0c29cf
|
1259 |
|
cc5e49
|
1260 |
return DummyTraverser |
0c29cf
|
1261 |
|
51c305
|
1262 |
|
e60985
|
1263 |
class DummyContext(object): |
dbab77
|
1264 |
__parent__ = None |
0c29cf
|
1265 |
|
7fc6a3
|
1266 |
def __init__(self, next=None, name=None): |
8b2c67
|
1267 |
self.next = next |
7fc6a3
|
1268 |
self.__name__ = name |
51c305
|
1269 |
|
8b2c67
|
1270 |
def __getitem__(self, name): |
CM |
1271 |
if self.next is None: |
e6c2d2
|
1272 |
raise KeyError(name) |
8b2c67
|
1273 |
return self.next |
7de404
|
1274 |
|
7fc6a3
|
1275 |
def __repr__(self): |
0c29cf
|
1276 |
return '<DummyContext with name %s at id %s>' % ( |
MM |
1277 |
self.__name__, |
|
1278 |
id(self), |
|
1279 |
) |
|
1280 |
|
7fc6a3
|
1281 |
|
7de404
|
1282 |
class DummyRequest: |
def68d
|
1283 |
|
0c29cf
|
1284 |
application_url = ( |
MM |
1285 |
'http://example.com:5432' |
|
1286 |
) # app_url never ends with slash |
def68d
|
1287 |
matchdict = None |
CM |
1288 |
matched_route = None |
|
1289 |
|
ebcdc7
|
1290 |
def __init__(self, environ=None, path_info=text_('/'), toraise=None): |
e62e47
|
1291 |
if environ is None: |
CM |
1292 |
environ = {} |
|
1293 |
self.environ = environ |
def68d
|
1294 |
self._set_path_info(path_info) |
CM |
1295 |
self.toraise = toraise |
|
1296 |
|
|
1297 |
def _get_path_info(self): |
|
1298 |
if self.toraise: |
|
1299 |
raise self.toraise |
|
1300 |
return self._path_info |
|
1301 |
|
|
1302 |
def _set_path_info(self, v): |
|
1303 |
self._path_info = v |
|
1304 |
|
|
1305 |
path_info = property(_get_path_info, _set_path_info) |
0c29cf
|
1306 |
|
dfc2b6
|
1307 |
|
6fec21
|
1308 |
def _makeRequest(environ=None): |
b60bdb
|
1309 |
from pyramid.registry import Registry |
0c29cf
|
1310 |
|
6fec21
|
1311 |
request = DummyRequest() |
CM |
1312 |
request.registry = Registry() |
|
1313 |
return request |