author | Tero Marttila <terom@fixme.fi> |
Mon, 16 Feb 2009 21:52:03 +0200 | |
changeset 85 | fd4b9a80e602 |
parent 84 | 65dcbedaa5f5 |
permissions | -rw-r--r-- |
81 | 1 |
# :set encoding=utf8 |
79 | 2 |
""" |
3 |
Unit tests for qmsk.web.urltree |
|
4 |
""" |
|
5 |
||
6 |
import unittest |
|
7 |
import urltree |
|
8 |
||
9 |
class TestLabelValue (unittest.TestCase) : |
|
10 |
class dummylabel : |
|
11 |
key = 'foo' |
|
12 |
||
13 |
def test_str_default (self) : |
|
14 |
self.assertEqual(str(urltree.LabelValue(self.dummylabel, 'bar', True)), "foo") |
|
15 |
||
16 |
def test_str_value (self) : |
|
17 |
self.assertEqual(str(urltree.LabelValue(self.dummylabel, 'bar', False)), "foo='bar'") |
|
18 |
||
19 |
class TestLabel (unittest.TestCase) : |
|
20 |
def setUp (self) : |
|
21 |
self.config = urltree.URLConfig() |
|
22 |
||
23 |
def _test_parse (self, mask, _type, defaults={}, **attrs) : |
|
24 |
label = urltree.Label.parse(mask, defaults, self.config) |
|
25 |
||
26 |
self.assertTrue(isinstance(label, _type)) |
|
27 |
||
28 |
for k, v in attrs.iteritems() : |
|
29 |
self.assertEqual(getattr(label, k), v) |
|
30 |
||
31 |
def test_parse_empty (self) : |
|
32 |
self._test_parse("", urltree.EmptyLabel) |
|
33 |
||
34 |
def test_parse_static (self) : |
|
35 |
self._test_parse("foo", urltree.StaticLabel, name="foo") |
|
36 |
||
37 |
def test_parse_static_valid (self) : |
|
38 |
self._test_parse("foo_bar", urltree.StaticLabel, name="foo_bar") |
|
39 |
self._test_parse("foo2", urltree.StaticLabel, name="foo2") |
|
40 |
self._test_parse("2foo.q", urltree.StaticLabel, name="2foo.q") |
|
41 |
||
42 |
def test_parse_static_invalid (self) : |
|
43 |
self.assertRaises(urltree.URLError, urltree.Label.parse, "foo/bar", {}, self.config) |
|
44 |
||
45 |
def test_parse_value_plain (self) : |
|
46 |
self._test_parse("{foo}", urltree.SimpleValueLabel, key="foo", default=None, type_name=None, type=urltree.URLConfig.BUILTIN_TYPES[None]) |
|
47 |
||
48 |
def test_parse_value_default1 (self) : |
|
49 |
self._test_parse("{foo=bar1}", urltree.SimpleValueLabel, key="foo", default="bar1", type_name=None) |
|
50 |
||
51 |
def test_parse_value_default2 (self) : |
|
52 |
self._test_parse("{foo}", urltree.SimpleValueLabel, dict(foo="bar2"), key="foo", default="bar2", type_name=None) |
|
53 |
||
54 |
def test_parse_value_default3 (self) : |
|
55 |
self._test_parse("{foo=bar1}", urltree.SimpleValueLabel, dict(foo="bar3"), key="foo", default="bar3", type_name=None) |
|
56 |
||
57 |
def test_parse_value_type_str (self) : |
|
58 |
self._test_parse("{foo:str}", urltree.SimpleValueLabel, key="foo", type_name="str", type=urltree.URLConfig.BUILTIN_TYPES['str']) |
|
59 |
||
60 |
def test_parse_value_type_int (self) : |
|
61 |
self._test_parse("{foo:int}", urltree.SimpleValueLabel, key="foo", type_name="int", type=urltree.URLConfig.BUILTIN_TYPES['int']) |
|
62 |
||
82 | 63 |
def test_parse_invalid_type (self) : |
64 |
self.assertRaises(KeyError, self._test_parse, "{foo:bar}", None) |
|
65 |
||
79 | 66 |
class TestEmptyLabel (unittest.TestCase) : |
67 |
def setUp (self) : |
|
68 |
self.label = urltree.EmptyLabel() |
|
69 |
||
70 |
def test_eq (self) : |
|
71 |
self.assertTrue(self.label == urltree.EmptyLabel()) |
|
72 |
self.assertFalse(self.label == urltree.StaticLabel("foo")) |
|
73 |
||
74 |
def test_match (self) : |
|
75 |
self.assertFalse(self.label.match()) |
|
76 |
self.assertFalse(self.label.match("foo")) |
|
77 |
self.assertTrue(self.label.match("")) |
|
78 |
||
79 |
def test_build (self) : |
|
80 |
self.assertEqual(self.label.build({}), "") |
|
81 |
||
82 |
def test_build_default (self) : |
|
83 |
self.assertEqual(self.label.build_default({}), (False, "")) |
|
84 |
||
85 |
def test_str (self) : |
|
86 |
self.assertEqual(str(self.label), "") |
|
87 |
||
88 |
class TestStaticLabel (unittest.TestCase) : |
|
89 |
def setUp (self) : |
|
90 |
self.label = urltree.StaticLabel("test") |
|
91 |
||
92 |
def test_eq (self) : |
|
93 |
self.assertTrue(self.label == urltree.StaticLabel("test")) |
|
94 |
self.assertFalse(self.label == urltree.StaticLabel("Test")) |
|
95 |
self.assertFalse(self.label == urltree.EmptyLabel()) |
|
96 |
||
97 |
def test_match (self) : |
|
98 |
self.assertFalse(self.label.match()) |
|
99 |
self.assertFalse(self.label.match("foo")) |
|
100 |
self.assertTrue(self.label.match("test")) |
|
101 |
||
102 |
def test_build (self) : |
|
103 |
self.assertEqual(self.label.build({}), "test") |
|
104 |
||
105 |
def test_build_default (self) : |
|
106 |
self.assertEqual(self.label.build_default({}), (False, "test")) |
|
107 |
||
108 |
def test_str (self) : |
|
109 |
self.assertEqual(str(self.label), "test") |
|
110 |
||
111 |
class TestSimpleValueLabel (unittest.TestCase) : |
|
112 |
def setUp (self) : |
|
113 |
self.label = urltree.SimpleValueLabel("test", 'int', urltree.URLConfig.BUILTIN_TYPES['int'], None) |
|
114 |
self.label_default_0 = urltree.SimpleValueLabel("test", 'int', urltree.URLConfig.BUILTIN_TYPES['int'], 0) |
|
115 |
self.label_default_1 = urltree.SimpleValueLabel("test", 'int', urltree.URLConfig.BUILTIN_TYPES['int'], 1) |
|
116 |
self.label_str = urltree.SimpleValueLabel("test", None, urltree.URLConfig.BUILTIN_TYPES[None], None) |
|
117 |
self.label_str_default = urltree.SimpleValueLabel("test", None, urltree.URLConfig.BUILTIN_TYPES[None], 'def') |
|
118 |
||
119 |
def test_eq (self) : |
|
120 |
self.assertTrue(self.label == urltree.SimpleValueLabel("test", 'str', None, 1)) |
|
121 |
self.assertFalse(self.label == urltree.StaticLabel("Test")) |
|
122 |
self.assertFalse(self.label == urltree.EmptyLabel()) |
|
123 |
||
124 |
def _check_value (self, label, label_value, value, is_default) : |
|
125 |
self.assertTrue(isinstance(label_value, urltree.LabelValue)) |
|
126 |
self.assertEqual(label_value.label, label) |
|
127 |
self.assertEqual(label_value.value, value) |
|
128 |
self.assertEqual(label_value.is_default, is_default) |
|
129 |
||
130 |
def test_match_default_none (self) : |
|
131 |
self.assertEquals(self.label.match(), None) |
|
132 |
||
133 |
def test_match_default_value (self) : |
|
134 |
self._check_value(self.label_default_0, self.label_default_0.match(), 0, True) |
|
135 |
self._check_value(self.label_default_1, self.label_default_1.match(), 1, True) |
|
136 |
||
137 |
def test_match_invalid (self) : |
|
138 |
self.assertEquals(self.label.match("foo"), False) |
|
139 |
self.assertEquals(self.label_default_0.match("foo"), False) |
|
140 |
self.assertEquals(self.label_default_1.match("foo"), False) |
|
141 |
||
142 |
def test_match_valid (self) : |
|
143 |
self._check_value(self.label, self.label.match("0"), 0, False) |
|
144 |
self._check_value(self.label, self.label.match("1"), 1, False) |
|
145 |
self._check_value(self.label_default_0, self.label_default_0.match("1"), 1, False) |
|
146 |
self._check_value(self.label_default_1, self.label_default_1.match("0"), 0, False) |
|
147 |
||
148 |
def test_build (self) : |
|
149 |
self.assertEqual(self.label.build(dict(test=1)), "1") |
|
150 |
||
151 |
def test_build_nodefault (self) : |
|
152 |
self.assertRaises(urltree.URLError, self.label.build, {}) |
|
153 |
||
154 |
def test_build_none (self) : |
|
155 |
self.assertRaises(urltree.URLError, self.label.build, dict(test=None)) |
|
156 |
||
157 |
def test_build_default (self) : |
|
158 |
self.assertEqual(self.label_default_0.build_default({}), (True, "0")) |
|
159 |
self.assertEqual(self.label_default_1.build_default({}), (True, "1")) |
|
83 | 160 |
self.assertEqual(self.label_default_0.build_default(dict(test=0)), (True, "0")) |
79 | 161 |
|
162 |
def test_build_nonedefault (self) : |
|
163 |
self.assertEqual(self.label_default_1.build_default(dict(test=None)), (True, "1")) |
|
164 |
||
165 |
def test_build_value (self) : |
|
166 |
self.assertEqual(self.label.build_default(dict(test=0)), (False, "0")) |
|
167 |
self.assertEqual(self.label.build_default(dict(test=1)), (False, "1")) |
|
168 |
self.assertEqual(self.label_default_0.build_default(dict(test=1)), (False, "1")) |
|
169 |
||
170 |
def test_str (self) : |
|
171 |
self.assertEqual(str(self.label), "{test:int}") |
|
172 |
self.assertEqual(str(self.label_default_0), "{test:int=0}") |
|
173 |
self.assertEqual(str(self.label_default_1), "{test:int=1}") |
|
174 |
self.assertEqual(str(self.label_str), "{test}") |
|
175 |
self.assertEqual(str(self.label_str_default), "{test=def}") |
|
176 |
||
80 | 177 |
class TestStringType (unittest.TestCase) : |
178 |
def setUp (self) : |
|
179 |
self.type = urltree.URLStringType() |
|
180 |
||
181 |
def test_test (self) : |
|
182 |
self.assertTrue(self.type.test("")) |
|
183 |
self.assertTrue(self.type.test("xxx")) |
|
184 |
||
185 |
def test_parse (self) : |
|
186 |
self.assertEqual(self.type.parse(""), "") |
|
187 |
self.assertEqual(self.type.parse("xxx"), "xxx") |
|
188 |
||
189 |
def test_build (self) : |
|
190 |
self.assertEqual(self.type.build(""), "") |
|
191 |
self.assertEqual(self.type.build("xxx"), "xxx") |
|
192 |
self.assertEqual(self.type.build("äää"), "äää") |
|
193 |
||
194 |
class TestIntegerType (unittest.TestCase) : |
|
195 |
def setUp (self) : |
|
196 |
self.type = urltree.URLIntegerType() |
|
197 |
self.type_positive = urltree.URLIntegerType(allow_negative=False) |
|
198 |
self.type_nonzero = urltree.URLIntegerType(allow_zero=False) |
|
199 |
self.type_max_5 = urltree.URLIntegerType(max=5) |
|
200 |
||
201 |
def test_test (self) : |
|
202 |
self.assertTrue(self.type.test("1")) |
|
203 |
self.assertFalse(self.type.test("xx")) |
|
204 |
self.assertTrue(self.type_positive.test("1")) |
|
205 |
self.assertFalse(self.type_positive.test("-1")) |
|
206 |
self.assertTrue(self.type_nonzero.test("1")) |
|
207 |
self.assertFalse(self.type_nonzero.test("0")) |
|
208 |
self.assertTrue(self.type_max_5.test("5")) |
|
209 |
self.assertFalse(self.type_max_5.test("6")) |
|
210 |
||
211 |
def test_parse_invalid (self) : |
|
212 |
self.assertRaises(ValueError, self.type.parse, "xx") |
|
213 |
self.assertRaises(ValueError, self.type_nonzero.parse, "0") |
|
214 |
||
215 |
def test_parse_valid (self) : |
|
216 |
self.assertEqual(self.type.parse("0"), 0) |
|
217 |
self.assertEqual(self.type.parse("2"), 2) |
|
218 |
self.assertEqual(self.type_nonzero.parse("3"), 3) |
|
219 |
||
220 |
def test_append (self) : |
|
81 | 221 |
self.assertRaises(urltree.URLError, self.type.append, 0, 1) |
80 | 222 |
|
223 |
def test_build (self) : |
|
224 |
self.assertEqual(self.type.build(0), "0") |
|
225 |
self.assertEqual(self.type.build(5), "5") |
|
226 |
self.assertEqual(self.type_positive.build(1), "1") |
|
227 |
self.assertEqual(self.type_nonzero.build(1), "1") |
|
228 |
self.assertEqual(self.type_max_5.build(5), "5") |
|
229 |
||
230 |
def test_build_invalid (self) : |
|
231 |
self.assertRaises(ValueError, self.type_positive.build, -1) |
|
232 |
self.assertRaises(ValueError, self.type_nonzero.build, 0) |
|
81 | 233 |
self.assertRaises(ValueError, self.type_max_5.build, 6) |
80 | 234 |
|
235 |
def test_build_multi (self) : |
|
81 | 236 |
self.assertEqual(self.type.build_multi(0), ["0"]) |
80 | 237 |
|
238 |
class TestListType (unittest.TestCase) : |
|
239 |
def setUp (self) : |
|
240 |
self.type = urltree.URLListType() |
|
241 |
||
242 |
def test_parse (self) : |
|
243 |
self.assertEqual(self.type.parse("x"), ["x"]) |
|
244 |
self.assertEqual(self.type.parse(""), [""]) |
|
245 |
||
246 |
def test_append (self) : |
|
247 |
self.assertEqual(self.type.append(["x"], ["y"]), ["x", "y"]) |
|
248 |
||
249 |
def test_build_multi (self) : |
|
250 |
self.assertEqual(self.type.build_multi(["x", "y"]), ["x", "y"]) |
|
251 |
||
252 |
class TestConfig (unittest.TestCase) : |
|
253 |
def test_init (self) : |
|
254 |
urltree.URLConfig(type_dict=dict(foo=None), ignore_extra_args=True) |
|
255 |
||
256 |
def test_get_type (self) : |
|
257 |
self.assertEquals(urltree.URLConfig(dict(foo='xxx')).get_type('foo'), 'xxx') |
|
82 | 258 |
|
259 |
def test_get_type_invalid (self) : |
|
260 |
self.assertRaises(KeyError, urltree.URLConfig(dict(foo='xxx')).get_type, 'xxx') |
|
80 | 261 |
|
262 |
def test_call (self) : |
|
263 |
config = urltree.URLConfig() |
|
264 |
url = config("foo", None) |
|
265 |
||
266 |
self.assertTrue(isinstance(url, urltree.URL)) |
|
267 |
self.assertTrue(url in config.urls) |
|
268 |
||
269 |
def test_iter (self) : |
|
270 |
config = urltree.URLConfig() |
|
271 |
url1 = config("foo1", None) |
|
272 |
url2 = config("foo2", None) |
|
273 |
||
274 |
urls = list(config) |
|
275 |
||
276 |
self.assertTrue(urls[0].url_mask == "foo1") |
|
277 |
self.assertTrue(urls[1].url_mask == "foo2") |
|
278 |
||
82 | 279 |
class TestURL (unittest.TestCase) : |
280 |
def setUp (self) : |
|
281 |
self.config = urltree.URLConfig(ignore_extra_args=True) |
|
282 |
self.config_strict = urltree.URLConfig(ignore_extra_args=False) |
|
283 |
||
284 |
def _test_label_path (self, mask, *path, **qargs) : |
|
285 |
url = self.config(mask, None) |
|
286 |
||
287 |
# right label path |
|
288 |
self.assertEquals(url.label_path, list(path)) |
|
289 |
||
290 |
# right qargs keys |
|
291 |
self.assertEquals(set(url.query_args), set(qargs)) |
|
292 |
||
293 |
# right qargs values |
|
294 |
for key, value in qargs.iteritems() : |
|
295 |
self.assertEquals(url.query_args[key], value) |
|
83 | 296 |
|
297 |
# __init__ |
|
82 | 298 |
def test_label_path_empty (self) : |
299 |
self._test_label_path("", urltree.EmptyLabel()) |
|
300 |
||
301 |
def test_label_path_root (self) : |
|
302 |
self._test_label_path("/", urltree.EmptyLabel()) |
|
303 |
||
304 |
def test_label_path_static (self) : |
|
305 |
self._test_label_path("/foo", urltree.StaticLabel("foo")) |
|
306 |
||
307 |
def test_label_path_static2 (self) : |
|
308 |
self._test_label_path("/foo/bar/", urltree.StaticLabel("foo"), urltree.StaticLabel("bar"), urltree.EmptyLabel()) |
|
309 |
||
310 |
def test_label_path_mix (self) : |
|
311 |
self._test_label_path("/foo/{bar}", urltree.StaticLabel("foo"), urltree.SimpleValueLabel("bar", None, None, None)) |
|
312 |
||
313 |
# def test_query_args_root_empty (self) : |
|
314 |
# self._test_label_path("/?", urltree.EmptyLabel()) |
|
315 |
||
316 |
def test_query_args_simple (self) : |
|
317 |
self._test_label_path("/x/?foo", urltree.StaticLabel("x"), foo=(self.config.get_type(None), None)) |
|
318 |
||
319 |
def test_query_args_multi (self) : |
|
320 |
self._test_label_path("/x/?foo=0&bar&tee:int=&eee:int", urltree.StaticLabel("x"), |
|
321 |
foo = (self.config.get_type(None), "0"), |
|
322 |
bar = (self.config.get_type(None), None), |
|
323 |
tee = (self.config.get_type('int'), ''), |
|
324 |
eee = (self.config.get_type('int'), None), |
|
325 |
) |
|
326 |
||
327 |
def test_label_path_mutate (self) : |
|
328 |
l = self.config("xxx", None) |
|
329 |
||
330 |
lp = l.get_label_path() |
|
331 |
||
332 |
lp.pop(0) |
|
333 |
||
334 |
self.assertTrue(len(l.label_path) > len(lp)) |
|
335 |
||
336 |
def _setup_handler (self) : |
|
337 |
def _handler (req, **kwargs) : |
|
338 |
return kwargs |
|
339 |
||
340 |
return _handler |
|
341 |
||
342 |
def _setup_execute (self, mask, config) : |
|
343 |
_handler = self._setup_handler() |
|
344 |
||
345 |
url = config(mask, _handler) |
|
346 |
||
347 |
return url |
|
348 |
||
349 |
class dummyrequest : |
|
350 |
def __init__ (self, qargs) : self.qargs = qargs |
|
351 |
def get_args (self) : return self.qargs |
|
352 |
||
353 |
class dummy_label : |
|
354 |
def __init__ (self, key, type) : |
|
355 |
self.key = key |
|
356 |
self.type = type |
|
357 |
||
358 |
class dummy_labelvalue : |
|
359 |
def __init__ (self, key, value, is_default, type) : |
|
360 |
self.label = TestURL.dummy_label(key, type) |
|
361 |
self.value = value |
|
362 |
self.is_default = is_default |
|
363 |
||
364 |
def _test_execute (self, mask, values={}, qargs={}, qlist=[], config=None) : |
|
365 |
if not config : |
|
366 |
config = self.config |
|
367 |
||
368 |
# setup |
|
369 |
url = self._setup_execute(mask, config) |
|
370 |
req = self.dummyrequest(qargs.items() + qlist) |
|
371 |
values = [self.dummy_labelvalue(k, v, d, config.get_type()) for k, (v, d) in values.iteritems()] |
|
372 |
||
373 |
# exec |
|
374 |
out_args = url.execute(req, values) |
|
375 |
||
376 |
return out_args |
|
83 | 377 |
|
378 |
# execute |
|
82 | 379 |
def test_execute_empty (self) : |
380 |
self.assertEquals(set(self._test_execute("/")), set()) |
|
381 |
||
382 |
def test_execute_plain (self) : |
|
383 |
self.assertEquals(set(self._test_execute("/foo")), set()) |
|
384 |
||
385 |
def test_execute_simple (self) : |
|
386 |
self.assertEquals(self._test_execute("/foo/{bar}", dict(bar=(0, False))), dict(bar=0)) |
|
387 |
||
388 |
def test_execute_multi (self) : |
|
389 |
self.assertEquals(self._test_execute("/foo/{bar}/{quux}", dict(bar=(1, False), quux=(2, False))), dict(bar=1, quux=2)) |
|
390 |
||
391 |
def test_execute_default (self) : |
|
392 |
self.assertEquals(self._test_execute("/foo/{bar=0}", dict(bar=("0", True))), dict(bar="0")) |
|
393 |
||
394 |
def test_execute_qargs_default (self) : |
|
395 |
self.assertEquals(self._test_execute("/{foo}/?bar=0", dict(foo=("x", False))), dict(foo="x", bar="0")) |
|
396 |
||
397 |
def test_execute_qargs_default_type (self) : |
|
398 |
self.assertEquals(self._test_execute("/{foo}/?bar:int=0", dict(foo=("x", False))), dict(foo="x", bar=0)) |
|
399 |
||
400 |
def test_execute_qargs_default_none (self) : |
|
401 |
self.assertEquals(self._test_execute("/{foo}/?bar=", dict(foo=("x", False))), dict(foo="x")) |
|
402 |
||
403 |
def test_execute_qargs_missing (self) : |
|
404 |
self.assertRaises(urltree.URLError, self._test_execute, "/{foo}/?bar", dict(foo=("x", False))) |
|
405 |
||
406 |
def test_execute_qargs_invalid (self) : |
|
407 |
self.assertRaises(ValueError, self._test_execute, "/{foo}/?bar:int", dict(foo=("x", False)), dict(bar="x")) |
|
408 |
||
409 |
def test_execute_qargs_simple (self) : |
|
410 |
self.assertEquals(self._test_execute("/{foo}/?bar", dict(foo=("x", False)), dict(bar="y")), dict(foo="x", bar="y")) |
|
411 |
||
412 |
def test_execute_qargs_novalue (self) : |
|
413 |
self.assertRaises(urltree.URLError, self._test_execute, "/{foo}/?bar", dict(foo=("x", False)), dict(bar='')) |
|
414 |
||
415 |
def test_execute_qargs_multi_invalid (self) : |
|
416 |
self.assertRaises(urltree.URLError, self._test_execute, "/{foo}/?bar", dict(foo=("x", False)), qlist=[('bar', 'a'), ('bar', 'b')]) |
|
417 |
||
418 |
def test_execute_qargs_multi_list (self) : |
|
419 |
self.assertEqual(self._test_execute("/{foo}/?bar:list", dict(foo=("x", False)), qlist=[('bar', 'a'), ('bar', 'b')]), dict(foo='x', bar=['a', 'b'])) |
|
420 |
||
421 |
def test_execute_qarg_override_strict (self) : |
|
422 |
self.assertRaises(urltree.URLError, self._test_execute, "/{foo}", dict(foo=("x1", False)), dict(foo="x2"), config=self.config_strict) |
|
423 |
||
424 |
def test_execute_qarg_override_ignore (self) : |
|
425 |
self.assertEqual(self._test_execute("/{foo}", dict(foo=("x1", False)), dict(foo="x2")), dict(foo="x1")) |
|
426 |
||
427 |
def test_execute_qarg_override_ok (self) : |
|
428 |
self.assertEqual(self._test_execute("/{foo=x1}", dict(foo=("x1", True)), dict(foo="x2")), dict(foo="x2")) |
|
83 | 429 |
|
430 |
# build |
|
431 |
class dummyrequest_page : |
|
432 |
def __init__ (self, page_prefix) : |
|
433 |
self.page_prefix = page_prefix |
|
434 |
||
435 |
def _test_build (self, mask, url, **args) : |
|
436 |
self.assertEquals(self.config(mask, None).build(self.dummyrequest_page("/index.cgi"), **args), "/index.cgi" + url) |
|
437 |
||
438 |
def _test_build_fails (self, err, mask, **args) : |
|
439 |
self.assertRaises(err, self.config(mask, None).build, self.dummyrequest_page("/index.cgi"), **args) |
|
82 | 440 |
|
83 | 441 |
def test_build_empty (self) : |
442 |
self._test_build("/", "/") |
|
443 |
||
444 |
def test_build_static (self) : |
|
445 |
self._test_build("/foo", "/foo") |
|
446 |
||
447 |
def test_build_simple (self) : |
|
448 |
self._test_build("/foo/{bar}", "/foo/x", bar="x") |
|
449 |
||
450 |
def test_build_multi (self) : |
|
451 |
self._test_build("/foo/{bar}/{quux}", "/foo/x/y", bar="x", quux="y") |
|
452 |
||
453 |
def test_build_missing (self) : |
|
454 |
self._test_build_fails(urltree.URLError, "/foo/{bar}/{quux}", bar="x") |
|
455 |
||
456 |
def test_build_unknown (self) : |
|
457 |
self._test_build_fails(urltree.URLError, "/foo/{bar}/{quux}", bar="x", quux="y", frob="???") |
|
458 |
||
459 |
def test_build_long (self) : |
|
460 |
self._test_build("/foo/{bar=a}/{quux=b}", "/foo/x/y", bar="x", quux="y") |
|
461 |
||
462 |
def test_build_short (self) : |
|
463 |
self._test_build("/foo/{bar=a}/{quux=b}", "/foo/x", bar="x", quux="b") |
|
464 |
||
465 |
def test_build_with_none (self) : |
|
466 |
self._test_build("/foo/{bar=a}/{quux=b}", "/foo/x", bar="x", quux=None) |
|
467 |
||
468 |
def test_build_default (self) : |
|
469 |
self._test_build("/foo/{bar=a}/{quux=b}", "/foo/x", bar="x") |
|
470 |
||
471 |
def test_build_qargs (self) : |
|
472 |
self._test_build("/foo/{bar}/?quux", "/foo/x?quux=a", bar="x", quux="a") |
|
473 |
||
474 |
def test_build_qargs_default (self) : |
|
475 |
self._test_build("/foo/{bar}/?quux", "/foo/x?quux=a", bar="x", quux="a") |
|
476 |
||
477 |
# XXX: this just becomes ...?quux=['a', 'b'] like from str(list) |
|
478 |
# def test_build_qargs_multi_invalid (self) : |
|
84 | 479 |
# self._test_build_fails(urltree.URLError, "/foo/{bar}/?quux", bar="x", quux=["a", "b"]) |
83 | 480 |
|
481 |
def test_build_qargs_multi_list (self) : |
|
482 |
self._test_build("/foo/{bar}/?quux:list", "/foo/x?quux=a&quux=b", bar="x", quux=["a", "b"]) |
|
483 |
||
484 |
def test_build_qargs_none (self) : |
|
485 |
self._test_build("/foo/{bar}/?quux", "/foo/x", bar="x", quux=None) |
|
486 |
||
84 | 487 |
class TestTreeBuild (unittest.TestCase) : |
488 |
def setUp (self) : |
|
489 |
self.config = urltree.URLConfig(ignore_extra_args=True) |
|
83 | 490 |
|
84 | 491 |
def test_simple_root (self) : |
492 |
self.config("/", None) |
|
493 |
self.assertEqual(str(urltree.URLTree(self.config).root), "/[]") |
|
83 | 494 |
|
84 | 495 |
def test_simple_static (self) : |
496 |
self.config("/foo/bar", None) |
|
497 |
self.assertEqual(str(urltree.URLTree(self.config).root), "/[foo/[bar/[]]]") |
|
498 |
||
499 |
def test_multi_static (self) : |
|
500 |
self.config("/foo/bar", None) |
|
501 |
self.config("/foo/quux", None) |
|
502 |
self.config("/asdf", None) |
|
503 |
self.assertEqual(str(urltree.URLTree(self.config).root), "/[foo/[bar/[],quux/[]],asdf/[]]") |
|
504 |
||
505 |
def test_simple_value (self) : |
|
506 |
self.config("/foo/{bar}", None) |
|
507 |
self.assertEqual(str(urltree.URLTree(self.config).root), "/[foo/[{bar}/[]]]") |
|
508 |
||
509 |
def test_deep (self) : |
|
510 |
self.config("/foo/{cc}/a", None) |
|
511 |
self.config("/foo/{cc}/b", None) |
|
512 |
self.assertEqual(str(urltree.URLTree(self.config).root), "/[foo/[{cc}/[a/[],b/[]]]]") |
|
513 |
||
514 |
def test_deep2 (self) : |
|
515 |
self.config("/foo/{cc}/a/x", None) |
|
516 |
self.config("/foo/{cc}/b", None) |
|
517 |
self.assertEqual(str(urltree.URLTree(self.config).root), "/[foo/[{cc}/[a/[x/[]],b/[]]]]") |
|
518 |
||
519 |
def test_ambig_simple (self) : |
|
520 |
self.config("/foo", None) |
|
521 |
self.config("/foo", None) |
|
522 |
||
523 |
self.assertRaises(urltree.URLError, urltree.URLTree, self.config) |
|
524 |
||
525 |
class TestTreeMatch (unittest.TestCase) : |
|
526 |
def setUp (self) : |
|
527 |
self.config = urltree.URLConfig(ignore_extra_args=True) |
|
528 |
||
529 |
self.root =self.config("/", None) |
|
530 |
self.bar = self.config("/bar", None) |
|
531 |
self.quux = self.config("/quux/{xyz}", None) |
|
532 |
self.quux_boo = self.config("/quux/{xyz}/boo/{opt=no}", None) |
|
533 |
self.quux_yes = self.config("/quux/{xyz}/yes", None) |
|
534 |
||
535 |
self.tree = urltree.URLTree(self.config) |
|
536 |
||
537 |
def _test_match (self, path, url, **values) : |
|
538 |
t_url, t_values = self.tree.match(path) |
|
539 |
||
540 |
self.assertEqual(t_url, url) |
|
541 |
||
542 |
self.assertEqual(set(v.label.key for v in t_values), set(values)) |
|
543 |
||
544 |
for v in t_values : |
|
545 |
self.assertEqual(v.value, values[v.label.key]) |
|
546 |
||
547 |
def test_root (self) : |
|
548 |
self._test_match("", self.root) |
|
549 |
||
550 |
def test_bar (self) : |
|
551 |
self._test_match("bar", self.bar) |
|
552 |
||
553 |
def test_bar_slash (self) : |
|
554 |
self._test_match("bar/", self.bar) |
|
555 |
||
556 |
def test_quux (self) : |
|
557 |
self._test_match("quux/a", self.quux, xyz="a") |
|
558 |
||
559 |
def test_quux_missing (self) : |
|
560 |
self.assertRaises(urltree.URLError, self._test_match, "quux/", None) |
|
561 |
||
562 |
def test_quux_boo (self) : |
|
563 |
self._test_match("quux/a/boo/x", self.quux_boo, xyz="a", opt="x") |
|
564 |
||
565 |
def test_quux_default (self) : |
|
566 |
self._test_match("quux/a/boo", self.quux_boo, xyz="a", opt="no") |
|
567 |
||
568 |
def test_yes (self) : |
|
569 |
self._test_match("quux/a/yes", self.quux_yes, xyz="a") |
|
570 |
||
85
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
571 |
class TestTreeHandler (unittest.TestCase) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
572 |
def _build_handler (self, name) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
573 |
def _handler (req, **args) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
574 |
return name, args |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
575 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
576 |
return _handler |
84 | 577 |
|
85
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
578 |
def setUp (self) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
579 |
self.config = urltree.URLConfig(ignore_extra_args=True) |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
580 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
581 |
self.root =self.config("/", self._build_handler('root')) |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
582 |
self.bar = self.config("/bar", self._build_handler('bar')) |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
583 |
self.quux = self.config("/quux/{xyz}", self._build_handler('quux')) |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
584 |
self.quux_boo = self.config("/quux/{xyz}/boo/{opt=no}", self._build_handler('quux_boo')) |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
585 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
586 |
self.tree = urltree.URLTree(self.config) |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
587 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
588 |
class dummyrequest_page : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
589 |
def __init__ (self, page_name, qargs) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
590 |
self.page_name = page_name |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
591 |
self.qargs = qargs |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
592 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
593 |
def get_page_name (self) : return self.page_name |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
594 |
def get_args (self) : return self.qargs |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
595 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
596 |
def _test_handle (self, path, name, qargs={}, **args) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
597 |
req = self.dummyrequest_page(path, qargs.iteritems()) |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
598 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
599 |
h_name, h_args = self.tree.handle_request(req) |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
600 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
601 |
self.assertEqual(h_name, name) |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
602 |
self.assertEqual(h_args, args) |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
603 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
604 |
def test_root (self) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
605 |
self._test_handle("", 'root') |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
606 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
607 |
def test_bar (self) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
608 |
self._test_handle("bar", 'bar') |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
609 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
610 |
def test_quux (self) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
611 |
self._test_handle("quux/a", 'quux', xyz='a') |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
612 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
613 |
def test_quux_boo (self) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
614 |
self._test_handle("quux/a/boo/b", 'quux_boo', xyz='a', opt='b') |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
615 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
616 |
def test_quux_boo_default (self) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
617 |
self._test_handle("quux/a/boo", 'quux_boo', xyz='a', opt='no') |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
618 |
|
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
619 |
def test_quux_boo_qarg (self) : |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
620 |
self._test_handle("quux/a/boo", 'quux_boo', dict(opt='yes'), xyz='a', opt='yes') |
fd4b9a80e602
coverage of urltree is fairly complete now
Tero Marttila <terom@fixme.fi>
parents:
84
diff
changeset
|
621 |