commit | author | age
|
a0b2c6
|
1 |
import unittest |
CM |
2 |
|
dd3cc8
|
3 |
from . import dummyfactory |
MM |
4 |
from . import DummyContext |
a5d994
|
5 |
from pyramid.compat import text_ |
a0b2c6
|
6 |
|
CM |
7 |
class RoutesConfiguratorMixinTests(unittest.TestCase): |
|
8 |
def _makeOne(self, *arg, **kw): |
|
9 |
from pyramid.config import Configurator |
|
10 |
config = Configurator(*arg, **kw) |
|
11 |
return config |
|
12 |
|
|
13 |
def _assertRoute(self, config, name, path, num_predicates=0): |
|
14 |
from pyramid.interfaces import IRoutesMapper |
|
15 |
mapper = config.registry.getUtility(IRoutesMapper) |
|
16 |
routes = mapper.get_routes() |
|
17 |
route = routes[0] |
|
18 |
self.assertEqual(len(routes), 1) |
|
19 |
self.assertEqual(route.name, name) |
|
20 |
self.assertEqual(route.path, path) |
|
21 |
self.assertEqual(len(routes[0].predicates), num_predicates) |
|
22 |
return route |
|
23 |
|
|
24 |
def _makeRequest(self, config): |
|
25 |
request = DummyRequest() |
|
26 |
request.registry = config.registry |
|
27 |
return request |
|
28 |
|
|
29 |
def test_get_routes_mapper_not_yet_registered(self): |
|
30 |
config = self._makeOne() |
|
31 |
mapper = config.get_routes_mapper() |
|
32 |
self.assertEqual(mapper.routelist, []) |
|
33 |
|
|
34 |
def test_get_routes_mapper_already_registered(self): |
|
35 |
from pyramid.interfaces import IRoutesMapper |
|
36 |
config = self._makeOne() |
|
37 |
mapper = object() |
|
38 |
config.registry.registerUtility(mapper, IRoutesMapper) |
|
39 |
result = config.get_routes_mapper() |
|
40 |
self.assertEqual(result, mapper) |
|
41 |
|
|
42 |
def test_add_route_defaults(self): |
|
43 |
config = self._makeOne(autocommit=True) |
|
44 |
config.add_route('name', 'path') |
|
45 |
self._assertRoute(config, 'name', 'path') |
|
46 |
|
|
47 |
def test_add_route_with_route_prefix(self): |
|
48 |
config = self._makeOne(autocommit=True) |
|
49 |
config.route_prefix = 'root' |
|
50 |
config.add_route('name', 'path') |
|
51 |
self._assertRoute(config, 'name', 'root/path') |
|
52 |
|
|
53 |
def test_add_route_discriminator(self): |
|
54 |
config = self._makeOne() |
|
55 |
config.add_route('name', 'path') |
412b4a
|
56 |
self.assertEqual(config.action_state.actions[-1]['discriminator'], |
CM |
57 |
('route', 'name')) |
a0b2c6
|
58 |
|
CM |
59 |
def test_add_route_with_factory(self): |
|
60 |
config = self._makeOne(autocommit=True) |
|
61 |
factory = object() |
|
62 |
config.add_route('name', 'path', factory=factory) |
|
63 |
route = self._assertRoute(config, 'name', 'path') |
|
64 |
self.assertEqual(route.factory, factory) |
|
65 |
|
|
66 |
def test_add_route_with_static(self): |
|
67 |
config = self._makeOne(autocommit=True) |
|
68 |
config.add_route('name', 'path/{foo}', static=True) |
|
69 |
mapper = config.get_routes_mapper() |
|
70 |
self.assertEqual(len(mapper.get_routes()), 0) |
|
71 |
self.assertEqual(mapper.generate('name', {"foo":"a"}), '/path/a') |
|
72 |
|
|
73 |
def test_add_route_with_factory_dottedname(self): |
|
74 |
config = self._makeOne(autocommit=True) |
|
75 |
config.add_route( |
|
76 |
'name', 'path', |
dd3cc8
|
77 |
factory='tests.test_config.dummyfactory') |
a0b2c6
|
78 |
route = self._assertRoute(config, 'name', 'path') |
CM |
79 |
self.assertEqual(route.factory, dummyfactory) |
|
80 |
|
|
81 |
def test_add_route_with_xhr(self): |
|
82 |
config = self._makeOne(autocommit=True) |
|
83 |
config.add_route('name', 'path', xhr=True) |
|
84 |
route = self._assertRoute(config, 'name', 'path', 1) |
|
85 |
predicate = route.predicates[0] |
|
86 |
request = self._makeRequest(config) |
|
87 |
request.is_xhr = True |
|
88 |
self.assertEqual(predicate(None, request), True) |
|
89 |
request = self._makeRequest(config) |
|
90 |
request.is_xhr = False |
|
91 |
self.assertEqual(predicate(None, request), False) |
|
92 |
|
|
93 |
def test_add_route_with_request_method(self): |
|
94 |
config = self._makeOne(autocommit=True) |
|
95 |
config.add_route('name', 'path', request_method='GET') |
|
96 |
route = self._assertRoute(config, 'name', 'path', 1) |
|
97 |
predicate = route.predicates[0] |
|
98 |
request = self._makeRequest(config) |
|
99 |
request.method = 'GET' |
|
100 |
self.assertEqual(predicate(None, request), True) |
|
101 |
request = self._makeRequest(config) |
|
102 |
request.method = 'POST' |
|
103 |
self.assertEqual(predicate(None, request), False) |
|
104 |
|
|
105 |
def test_add_route_with_path_info(self): |
|
106 |
config = self._makeOne(autocommit=True) |
|
107 |
config.add_route('name', 'path', path_info='/foo') |
|
108 |
route = self._assertRoute(config, 'name', 'path', 1) |
|
109 |
predicate = route.predicates[0] |
|
110 |
request = self._makeRequest(config) |
a5d994
|
111 |
request.upath_info = '/foo' |
a0b2c6
|
112 |
self.assertEqual(predicate(None, request), True) |
CM |
113 |
request = self._makeRequest(config) |
a5d994
|
114 |
request.upath_info = '/' |
CM |
115 |
self.assertEqual(predicate(None, request), False) |
|
116 |
|
|
117 |
def test_add_route_with_path_info_highorder(self): |
|
118 |
config = self._makeOne(autocommit=True) |
|
119 |
config.add_route('name', 'path', |
|
120 |
path_info=text_(b'/La Pe\xc3\xb1a', 'utf-8')) |
|
121 |
route = self._assertRoute(config, 'name', 'path', 1) |
|
122 |
predicate = route.predicates[0] |
|
123 |
request = self._makeRequest(config) |
|
124 |
request.upath_info = text_(b'/La Pe\xc3\xb1a', 'utf-8') |
|
125 |
self.assertEqual(predicate(None, request), True) |
|
126 |
request = self._makeRequest(config) |
|
127 |
request.upath_info = text_('/') |
|
128 |
self.assertEqual(predicate(None, request), False) |
|
129 |
|
|
130 |
def test_add_route_with_path_info_regex(self): |
|
131 |
config = self._makeOne(autocommit=True) |
|
132 |
config.add_route('name', 'path', |
|
133 |
path_info=text_(br'/La Pe\w*', 'utf-8')) |
|
134 |
route = self._assertRoute(config, 'name', 'path', 1) |
|
135 |
predicate = route.predicates[0] |
|
136 |
request = self._makeRequest(config) |
|
137 |
request.upath_info = text_(b'/La Pe\xc3\xb1a', 'utf-8') |
|
138 |
self.assertEqual(predicate(None, request), True) |
|
139 |
request = self._makeRequest(config) |
|
140 |
request.upath_info = text_('/') |
a0b2c6
|
141 |
self.assertEqual(predicate(None, request), False) |
CM |
142 |
|
|
143 |
def test_add_route_with_request_param(self): |
|
144 |
config = self._makeOne(autocommit=True) |
|
145 |
config.add_route('name', 'path', request_param='abc') |
|
146 |
route = self._assertRoute(config, 'name', 'path', 1) |
|
147 |
predicate = route.predicates[0] |
|
148 |
request = self._makeRequest(config) |
|
149 |
request.params = {'abc':'123'} |
|
150 |
self.assertEqual(predicate(None, request), True) |
|
151 |
request = self._makeRequest(config) |
|
152 |
request.params = {} |
|
153 |
self.assertEqual(predicate(None, request), False) |
|
154 |
|
|
155 |
def test_add_route_with_custom_predicates(self): |
b01f1d
|
156 |
import warnings |
a0b2c6
|
157 |
config = self._makeOne(autocommit=True) |
CM |
158 |
def pred1(context, request): pass |
|
159 |
def pred2(context, request): pass |
b01f1d
|
160 |
with warnings.catch_warnings(record=True) as w: |
CM |
161 |
warnings.filterwarnings('always') |
|
162 |
config.add_route('name', 'path', custom_predicates=(pred1, pred2)) |
|
163 |
self.assertEqual(len(w), 1) |
a0b2c6
|
164 |
route = self._assertRoute(config, 'name', 'path', 2) |
9c8ec5
|
165 |
self.assertEqual(len(route.predicates), 2) |
a0b2c6
|
166 |
|
CM |
167 |
def test_add_route_with_header(self): |
|
168 |
config = self._makeOne(autocommit=True) |
|
169 |
config.add_route('name', 'path', header='Host') |
|
170 |
route = self._assertRoute(config, 'name', 'path', 1) |
|
171 |
predicate = route.predicates[0] |
|
172 |
request = self._makeRequest(config) |
|
173 |
request.headers = {'Host':'example.com'} |
|
174 |
self.assertEqual(predicate(None, request), True) |
|
175 |
request = self._makeRequest(config) |
|
176 |
request.headers = {} |
|
177 |
self.assertEqual(predicate(None, request), False) |
|
178 |
|
|
179 |
def test_add_route_with_accept(self): |
|
180 |
config = self._makeOne(autocommit=True) |
|
181 |
config.add_route('name', 'path', accept='text/xml') |
|
182 |
route = self._assertRoute(config, 'name', 'path', 1) |
|
183 |
predicate = route.predicates[0] |
|
184 |
request = self._makeRequest(config) |
c3c83e
|
185 |
request.accept = DummyAccept('text/xml') |
a0b2c6
|
186 |
self.assertEqual(predicate(None, request), True) |
CM |
187 |
request = self._makeRequest(config) |
c3c83e
|
188 |
request.accept = DummyAccept('text/html') |
MM |
189 |
self.assertEqual(predicate(None, request), False) |
|
190 |
|
|
191 |
def test_add_route_with_accept_list(self): |
|
192 |
config = self._makeOne(autocommit=True) |
|
193 |
config.add_route('name', 'path', accept=['text/xml', 'text/plain']) |
|
194 |
route = self._assertRoute(config, 'name', 'path', 1) |
|
195 |
predicate = route.predicates[0] |
|
196 |
request = self._makeRequest(config) |
|
197 |
request.accept = DummyAccept('text/xml') |
|
198 |
self.assertEqual(predicate(None, request), True) |
|
199 |
request = self._makeRequest(config) |
|
200 |
request.accept = DummyAccept('text/plain') |
|
201 |
self.assertEqual(predicate(None, request), True) |
|
202 |
request = self._makeRequest(config) |
|
203 |
request.accept = DummyAccept('text/html') |
a0b2c6
|
204 |
self.assertEqual(predicate(None, request), False) |
CM |
205 |
|
4a9f4f
|
206 |
def test_add_route_with_wildcard_accept(self): |
MM |
207 |
config = self._makeOne(autocommit=True) |
|
208 |
config.add_route('name', 'path', accept='text/*') |
|
209 |
route = self._assertRoute(config, 'name', 'path', 1) |
|
210 |
predicate = route.predicates[0] |
|
211 |
request = self._makeRequest(config) |
|
212 |
request.accept = DummyAccept('text/xml', contains=True) |
|
213 |
self.assertEqual(predicate(None, request), True) |
|
214 |
request = self._makeRequest(config) |
|
215 |
request.accept = DummyAccept('application/json', contains=False) |
|
216 |
self.assertEqual(predicate(None, request), False) |
|
217 |
|
a0b2c6
|
218 |
def test_add_route_no_pattern_with_path(self): |
CM |
219 |
config = self._makeOne(autocommit=True) |
|
220 |
config.add_route('name', path='path') |
|
221 |
self._assertRoute(config, 'name', 'path') |
|
222 |
|
|
223 |
def test_add_route_no_path_no_pattern(self): |
|
224 |
from pyramid.exceptions import ConfigurationError |
|
225 |
config = self._makeOne() |
|
226 |
self.assertRaises(ConfigurationError, config.add_route, 'name') |
|
227 |
|
|
228 |
def test_add_route_with_pregenerator(self): |
|
229 |
config = self._makeOne(autocommit=True) |
|
230 |
config.add_route('name', 'pattern', pregenerator='123') |
|
231 |
route = self._assertRoute(config, 'name', 'pattern') |
|
232 |
self.assertEqual(route.pregenerator, '123') |
|
233 |
|
|
234 |
def test_add_route_no_view_with_view_attr(self): |
|
235 |
config = self._makeOne(autocommit=True) |
|
236 |
from pyramid.exceptions import ConfigurationError |
|
237 |
try: |
|
238 |
config.add_route('name', '/pattern', view_attr='abc') |
|
239 |
except ConfigurationError: |
|
240 |
pass |
|
241 |
else: # pragma: no cover |
|
242 |
raise AssertionError |
|
243 |
|
|
244 |
def test_add_route_no_view_with_view_context(self): |
|
245 |
config = self._makeOne(autocommit=True) |
|
246 |
from pyramid.exceptions import ConfigurationError |
|
247 |
try: |
|
248 |
config.add_route('name', '/pattern', view_context=DummyContext) |
|
249 |
except ConfigurationError: |
|
250 |
pass |
|
251 |
else: # pragma: no cover |
|
252 |
raise AssertionError |
|
253 |
|
|
254 |
def test_add_route_no_view_with_view_permission(self): |
|
255 |
config = self._makeOne(autocommit=True) |
|
256 |
from pyramid.exceptions import ConfigurationError |
|
257 |
try: |
|
258 |
config.add_route('name', '/pattern', view_permission='edit') |
|
259 |
except ConfigurationError: |
|
260 |
pass |
|
261 |
else: # pragma: no cover |
|
262 |
raise AssertionError |
|
263 |
|
|
264 |
def test_add_route_no_view_with_view_renderer(self): |
|
265 |
config = self._makeOne(autocommit=True) |
|
266 |
from pyramid.exceptions import ConfigurationError |
|
267 |
try: |
|
268 |
config.add_route('name', '/pattern', view_renderer='json') |
|
269 |
except ConfigurationError: |
|
270 |
pass |
|
271 |
else: # pragma: no cover |
|
272 |
raise AssertionError |
|
273 |
|
|
274 |
class DummyRequest: |
|
275 |
subpath = () |
|
276 |
matchdict = None |
|
277 |
def __init__(self, environ=None): |
|
278 |
if environ is None: |
|
279 |
environ = {} |
|
280 |
self.environ = environ |
|
281 |
self.params = {} |
|
282 |
self.cookies = {} |
c3c83e
|
283 |
|
MM |
284 |
class DummyAccept(object): |
4a9f4f
|
285 |
def __init__(self, *matches, **kw): |
c3c83e
|
286 |
self.matches = list(matches) |
4a9f4f
|
287 |
self.contains = kw.pop('contains', False) |
c3c83e
|
288 |
|
MM |
289 |
def acceptable_offers(self, offers): |
|
290 |
results = [] |
|
291 |
for match in self.matches: |
|
292 |
if match in offers: |
|
293 |
results.append((match, 1.0)) |
|
294 |
return results |
4a9f4f
|
295 |
|
MM |
296 |
def __contains__(self, value): |
|
297 |
return self.contains |