source: OpenRLabs-Git/deploy/rlabs-docker/web2py-rlabs/gluon/tests/test_router.py

main
Last change on this file was 42bd667, checked in by David Fuertes <dfuertes@…>, 4 years ago

Historial Limpio
  • Property mode set to 100755
File size: 76.5 KB
Line 
1# -*- coding: utf-8 -*-
2
3"""Unit tests for rewrite.py routers option"""
4
5import os
6import tempfile
7import logging
8import unittest
9import shutil
10
11from gluon.rewrite import (load, filter_url, filter_err,
12    get_effective_router, map_url_out)
13from gluon.html import URL
14from gluon.settings import global_settings
15from gluon.http import HTTP
16from gluon.storage import Storage
17from gluon._compat import to_bytes, PY2
18
19
20logger = None
21
22old_root = root = None
23
24def setUpModule():
25    def make_apptree(root):
26        "build a temporary applications tree"
27        # applications/
28        os.mkdir(os.path.join(root, 'applications'))
29        # applications/app/
30        for app in ('admin', 'examples', 'welcome'):
31            os.mkdir(os.path.join(root, 'applications', app))
32            #  applications/app/(controllers, static)
33            for subdir in ('controllers', 'static'):
34                os.mkdir(os.path.join(root, 'applications', app, subdir))
35        # applications/admin/controllers/*.py
36        base = os.path.join(root, 'applications', 'admin', 'controllers')
37        for ctr in ('appadmin', 'default', 'gae', 'mercurial', 'shell', 'wizard'):
38            open(os.path.join(base, '%s.py' % ctr), 'w').close()
39        # applications/examples/controllers/*.py
40        base = os.path.join(root, 'applications', 'examples', 'controllers')
41        for ctr in ('ajax_examples', 'appadmin', 'default', 'global', 'spreadsheet'):
42            open(os.path.join(base, '%s.py' % ctr), 'w').close()
43        # applications/welcome/controllers/*.py
44        # (include controller that collides with another app)
45        base = os.path.join(root, 'applications', 'welcome', 'controllers')
46        for ctr in ('appadmin', 'default', 'other', 'admin'):
47            open(os.path.join(base, '%s.py' % ctr), 'w').close()
48        # create an app-specific routes.py for examples app
49        routes = os.path.join(root, 'applications', 'examples', 'routes.py')
50        with open(routes, 'w') as r:
51            r.write("routers=dict(examples=dict(default_function='exdef'))")
52        # create language files for examples app
53        base = os.path.join(root, 'applications', 'examples', 'static')
54        for lang in ('en', 'it'):
55            os.mkdir(os.path.join(base, lang))
56            open(os.path.join(base, lang, 'file'), 'w').close()
57
58    global old_root, root, logger
59    if old_root is None:  # do this only once
60        old_root = global_settings.applications_parent
61        root = global_settings.applications_parent = tempfile.mkdtemp()
62        make_apptree(root)
63        logger = logging.getLogger('web2py.rewrite')
64
65
66def tearDownModule():
67    if old_root is not None:
68        global_settings.applications_parent = old_root
69        shutil.rmtree(root)
70
71
72def norm_root(root):
73    return root.replace('/', os.sep)
74
75
76class TestRouter(unittest.TestCase):
77    """ Tests the routers logic from gluon.rewrite """
78
79    def myassertRaisesRegex(self, *args, **kwargs):
80        if PY2:
81            return getattr(self, 'assertRaisesRegexp')(*args, **kwargs)
82        return getattr(self, 'assertRaisesRegex')(*args, **kwargs)
83
84    def test_router_syntax(self):
85        """ Test router syntax error """
86        level = logger.getEffectiveLevel()
87        logger.setLevel(logging.CRITICAL)  # disable logging temporarily
88        self.assertRaises(SyntaxError, load, data='x::y')
89        self.assertRaises(
90            SyntaxError, load, rdict=dict(BASE=dict(badkey="value")))
91        self.assertRaises(SyntaxError, load, rdict=dict(
92            BASE=dict(), app=dict(default_application="name")))
93
94        self.myassertRaisesRegex(SyntaxError, "invalid syntax",
95                                load, data='x::y')
96        self.myassertRaisesRegex(SyntaxError, "unknown key",
97                                load, rdict=dict(BASE=dict(badkey="value")))
98        self.myassertRaisesRegex(SyntaxError, "BASE-only key",
99                                load, rdict=dict(BASE=dict(), app=dict(default_application="name")))
100        logger.setLevel(level)
101
102    def test_router_null(self):
103        """ Tests the null router """
104        load(rdict=dict())
105        # app resolution
106        self.assertEqual(
107            filter_url('http://domain.com/welcome', app=True), 'welcome')
108        self.assertEqual(filter_url('http://domain.com/', app=True), 'init')
109        # incoming
110        self.assertEqual(filter_url('http://domain.com/favicon.ico'),
111                         norm_root('%s/applications/init/static/favicon.ico' % root))
112        self.assertEqual(
113            filter_url('http://domain.com/abc'), '/init/default/abc')
114        self.assertEqual(filter_url(
115            'http://domain.com/index/abc'), "/init/default/index ['abc']")
116        self.assertEqual(filter_url(
117            'http://domain.com/abc/def'), "/init/default/abc ['def']")
118        self.assertEqual(filter_url(
119            'http://domain.com/index/a%20bc'), "/init/default/index ['a bc']")
120        self.assertEqual(filter_url('http://domain.com/welcome/static/path/to/static').replace('/', os.sep),
121            norm_root("%s/applications/welcome/static/path/to/static" % root))
122        self.assertRaises(HTTP, filter_url, 'http://domain.com/welcome/static/bad/path/to/st~tic')
123        self.myassertRaisesRegex(HTTP, "400.*invalid static file", filter_url, 'http://domain.com/welcome/static/bad/path/to/st~tic')
124        # outgoing
125        self.assertEqual(
126            filter_url('http://domain.com/init/default/index', out=True), '/')
127        self.assertEqual(filter_url('http://domain.com/init/default/index/arg1', out=True), '/index/arg1')
128        self.assertEqual(filter_url(
129            'http://domain.com/init/default/abc', out=True), '/abc')
130        self.assertEqual(filter_url('http://domain.com/init/static/abc',
131                         out=True), '/init/static/abc')
132        self.assertEqual(filter_url(
133            'http://domain.com/init/appadmin/index', out=True), '/appadmin')
134        self.assertEqual(filter_url(
135            'http://domain.com/init/appadmin/abc', out=True), '/appadmin/abc')
136        self.assertEqual(filter_url(
137            'http://domain.com/init/admin/index', out=True), '/init/admin')
138        self.assertEqual(filter_url(
139            'http://domain.com/init/admin/abc', out=True), '/init/admin/abc')
140        self.assertEqual(filter_url(
141            'http://domain.com/admin/default/abc', out=True), '/admin/abc')
142
143    def test_router_specific(self):
144        """
145        Test app-specific routes.py
146
147        Note that make_apptree above created applications/examples/routes.py with a default_function.
148        """
149        load(rdict=dict())
150        self.assertEqual(
151            filter_url('http://domain.com/welcome'), '/welcome/default/index')
152        self.assertEqual(
153            filter_url('http://domain.com/examples'), '/examples/default/exdef')
154
155    def test_router_defapp(self):
156        """ Test the default-application function """
157        routers = dict(BASE=dict(default_application='welcome'))
158        load(rdict=routers)
159        # app resolution
160        self.assertEqual(
161            filter_url('http://domain.com/welcome', app=True), 'welcome')
162        self.assertEqual(filter_url('http://domain.com/', app=True), 'welcome')
163        # incoming
164        self.assertEqual(
165            filter_url('http://domain.com'), '/welcome/default/index')
166        self.assertEqual(
167            filter_url('http://domain.com/'), '/welcome/default/index')
168        self.assertEqual(filter_url(
169            'http://domain.com/appadmin'), '/welcome/appadmin/index')
170        self.assertEqual(
171            filter_url('http://domain.com/abc'), '/welcome/default/abc')
172        self.assertEqual(filter_url(
173            'http://domain.com/index/abc'), "/welcome/default/index ['abc']")
174        self.assertEqual(filter_url(
175            'http://domain.com/abc/def'), "/welcome/default/abc ['def']")
176        self.assertEqual(filter_url('http://domain.com/favicon.ico'),
177                         norm_root('%s/applications/welcome/static/favicon.ico' % root))
178        self.assertEqual(filter_url('http://domain.com/static/abc'),
179                         norm_root('%s/applications/welcome/static/abc' % root))
180        self.assertEqual(filter_url('http://domain.com/static/path/to/static').replace('/', os.sep),
181            norm_root("%s/applications/welcome/static/path/to/static" % root))
182        # outgoing
183        self.assertEqual(filter_url(
184            'http://domain.com/welcome/default/index', out=True), '/')
185        self.assertEqual(filter_url('http://domain.com/welcome/default/index/arg1', out=True), '/index/arg1')
186        self.assertEqual(filter_url(
187            'http://domain.com/welcome/default/abc', out=True), '/abc')
188        self.assertEqual(filter_url('http://domain.com/welcome/default/admin',
189                         out=True), '/default/admin')
190        self.assertEqual(
191            filter_url('http://domain.com/welcome/static/abc', out=True),
192            '/welcome/static/abc')
193        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/index',
194                         out=True), '/appadmin')
195        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/abc',
196                         out=True), '/appadmin/abc')
197        self.assertEqual(filter_url('http://domain.com/welcome/admin/index',
198                         out=True), '/welcome/admin')
199        self.assertEqual(filter_url('http://domain.com/welcome/admin/abc',
200                         out=True), '/welcome/admin/abc')
201        self.assertEqual(filter_url(
202            'http://domain.com/admin/default/abc', out=True), '/admin/abc')
203
204    def test_router_nodef(self):
205        """ Test no-default functions """
206        routers = dict(
207            BASE=dict(default_application='welcome'),
208            welcome=dict(controllers=None),
209        )
210        load(rdict=routers)
211        # outgoing
212        self.assertEqual(filter_url(
213            'http://domain.com/welcome/default/index', out=True), '/default')
214        self.assertEqual(filter_url('http://domain.com/welcome/default/index/arg1', out=True), '/default/index/arg1')
215        self.assertEqual(filter_url('http://domain.com/welcome/default/abc',
216                         out=True), '/default/abc')
217        self.assertEqual(
218            filter_url('http://domain.com/welcome/static/abc', out=True),
219            '/welcome/static/abc')
220        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/index',
221                         out=True), '/appadmin')
222        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/abc',
223                         out=True), '/appadmin/abc')
224        self.assertEqual(filter_url('http://domain.com/welcome/admin/index',
225                         out=True), '/welcome/admin')
226        self.assertEqual(filter_url('http://domain.com/welcome/admin/abc',
227                         out=True), '/welcome/admin/abc')
228        self.assertEqual(filter_url(
229            'http://domain.com/admin/default/abc', out=True), '/admin/abc')
230        # incoming
231        self.assertEqual(
232            filter_url('http://domain.com'), '/welcome/default/index')
233        self.assertEqual(
234            filter_url('http://domain.com/'), '/welcome/default/index')
235        self.assertEqual(filter_url(
236            'http://domain.com/appadmin'), '/welcome/appadmin/index')
237        self.assertEqual(
238            filter_url('http://domain.com/abc'), '/welcome/abc/index')
239        self.assertEqual(
240            filter_url('http://domain.com/index/abc'), "/welcome/index/abc")
241        self.assertEqual(
242            filter_url('http://domain.com/abc/def'), "/welcome/abc/def")
243        self.assertEqual(filter_url(
244            'http://domain.com/abc/def/ghi'), "/welcome/abc/def ['ghi']")
245
246        routers = dict(
247            BASE=dict(default_application=None),
248        )
249        load(rdict=routers)
250        # outgoing
251        self.assertEqual(filter_url(
252            'http://domain.com/welcome/default/index', out=True), '/welcome')
253        self.assertEqual(filter_url('http://domain.com/welcome/default/index/arg1', out=True), '/welcome/index/arg1')
254        self.assertEqual(filter_url('http://domain.com/welcome/default/abc',
255                         out=True), '/welcome/abc')
256        self.assertEqual(filter_url('http://domain.com/welcome/static/abc',
257                         out=True), '/welcome/static/abc')
258        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/index',
259                         out=True), '/welcome/appadmin')
260        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/abc',
261                         out=True), '/welcome/appadmin/abc')
262        self.assertEqual(filter_url('http://domain.com/welcome/admin/index',
263                         out=True), '/welcome/admin')
264        self.assertEqual(filter_url('http://domain.com/welcome/admin/abc',
265                         out=True), '/welcome/admin/abc')
266        self.assertEqual(filter_url(
267            'http://domain.com/admin/default/abc', out=True), '/admin/abc')
268        # incoming
269        self.assertRaises(HTTP, filter_url, 'http://domain.com')
270        self.assertRaises(HTTP, filter_url, 'http://domain.com/appadmin')
271        self.myassertRaisesRegex(HTTP, "400.*invalid application",
272                                filter_url, 'http://domain.com')
273        self.myassertRaisesRegex(HTTP, "400.*invalid application",
274                                    filter_url, 'http://domain.com/appadmin')
275        routers = dict(
276            BASE=dict(default_application='welcome', applications=None),
277        )
278        load(rdict=routers)
279        # outgoing
280        self.assertEqual(filter_url(
281            'http://domain.com/welcome/default/index', out=True), '/welcome')
282        self.assertEqual(filter_url('http://domain.com/welcome/default/index/arg1', out=True), '/welcome/index/arg1')
283        self.assertEqual(filter_url('http://domain.com/welcome/default/abc',
284                         out=True), '/welcome/abc')
285        self.assertEqual(filter_url('http://domain.com/welcome/static/abc',
286                         out=True), '/welcome/static/abc')
287        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/index',
288                         out=True), '/welcome/appadmin')
289        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/abc',
290                         out=True), '/welcome/appadmin/abc')
291        self.assertEqual(filter_url('http://domain.com/welcome/admin/index',
292                         out=True), '/welcome/admin')
293        self.assertEqual(filter_url('http://domain.com/welcome/admin/abc',
294                         out=True), '/welcome/admin/abc')
295        self.assertEqual(filter_url(
296            'http://domain.com/admin/default/abc', out=True), '/admin/abc')
297        # incoming
298        self.assertEqual(
299            filter_url('http://domain.com'), '/welcome/default/index')
300        self.assertEqual(
301            filter_url('http://domain.com/'), '/welcome/default/index')
302        self.assertRaises(HTTP, filter_url, 'http://domain.com/appadmin')
303        self.myassertRaisesRegex(HTTP, "400.*unknown application: 'appadmin'", filter_url, 'http://domain.com/appadmin')
304        routers = dict(
305            BASE=dict(default_application='welcome', applications=None),
306            welcome=dict(controllers=None),
307        )
308        load(rdict=routers)
309        # outgoing
310        self.assertEqual(filter_url('http://domain.com/welcome/default/index',
311                         out=True), '/welcome/default')
312        self.assertEqual(filter_url('http://domain.com/welcome/default/index/arg1', out=True), '/welcome/default/index/arg1')
313        self.assertEqual(filter_url('http://domain.com/welcome/default/abc',
314                         out=True), '/welcome/default/abc')
315        self.assertEqual(filter_url('http://domain.com/welcome/static/abc',
316                         out=True), '/welcome/static/abc')
317        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/index',
318                         out=True), '/welcome/appadmin')
319        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/abc',
320                         out=True), '/welcome/appadmin/abc')
321        self.assertEqual(filter_url('http://domain.com/welcome/admin/index',
322                         out=True), '/welcome/admin')
323        self.assertEqual(filter_url('http://domain.com/welcome/admin/abc',
324                         out=True), '/welcome/admin/abc')
325        self.assertEqual(filter_url(
326            'http://domain.com/admin/default/abc', out=True), '/admin/abc')
327        # incoming
328        self.assertEqual(
329            filter_url('http://domain.com'), '/welcome/default/index')
330        self.assertEqual(
331            filter_url('http://domain.com/'), '/welcome/default/index')
332        self.assertRaises(HTTP, filter_url, 'http://domain.com/appadmin')
333        self.myassertRaisesRegex(HTTP, "400.*unknown application: 'appadmin'", filter_url, 'http://domain.com/appadmin')
334
335        routers = dict(
336            BASE=dict(default_application='welcome', applications=None),
337            welcome=dict(default_controller=None),
338        )
339        load(rdict=routers)
340        # outgoing
341        self.assertEqual(filter_url('http://domain.com/welcome/default/index',
342                         out=True), '/welcome/default')
343        self.assertEqual(filter_url('http://domain.com/welcome/default/index/arg1', out=True), '/welcome/default/index/arg1')
344        self.assertEqual(filter_url('http://domain.com/welcome/default/abc',
345                         out=True), '/welcome/default/abc')
346        self.assertEqual(filter_url('http://domain.com/welcome/static/abc',
347                         out=True), '/welcome/static/abc')
348        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/index',
349                         out=True), '/welcome/appadmin')
350        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/abc',
351                         out=True), '/welcome/appadmin/abc')
352        self.assertEqual(filter_url('http://domain.com/welcome/admin/index',
353                         out=True), '/welcome/admin')
354        self.assertEqual(filter_url('http://domain.com/welcome/admin/abc',
355                         out=True), '/welcome/admin/abc')
356        self.assertEqual(filter_url(
357            'http://domain.com/admin/default/abc', out=True), '/admin/abc')
358        # incoming
359        self.assertRaises(HTTP, filter_url, 'http://domain.com')
360        self.assertRaises(HTTP, filter_url, 'http://domain.com/appadmin')
361        self.myassertRaisesRegex(HTTP, "400.*invalid controller",
362                                filter_url, 'http://domain.com')
363        self.myassertRaisesRegex(HTTP, "400.*unknown application: 'appadmin'", filter_url, 'http://domain.com/appadmin')
364
365        routers = dict(
366            BASE=dict(default_application='welcome', applications=None),
367            welcome=dict(controllers=None, default_function=None),
368        )
369        load(rdict=routers)
370        # outgoing
371        self.assertEqual(filter_url('http://domain.com/welcome/default/index',
372                         out=True), '/welcome/default/index')
373        self.assertEqual(filter_url('http://domain.com/welcome/default/index/arg1', out=True), '/welcome/default/index/arg1')
374        self.assertEqual(filter_url('http://domain.com/welcome/default/abc',
375                         out=True), '/welcome/default/abc')
376        self.assertEqual(filter_url('http://domain.com/welcome/static/abc',
377                         out=True), '/welcome/static/abc')
378        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/index',
379                         out=True), '/welcome/appadmin/index')
380        self.assertEqual(filter_url('http://domain.com/welcome/appadmin/abc',
381                         out=True), '/welcome/appadmin/abc')
382        self.assertEqual(filter_url('http://domain.com/welcome/admin/index',
383                         out=True), '/welcome/admin/index')
384        self.assertEqual(filter_url('http://domain.com/welcome/admin/abc',
385                         out=True), '/welcome/admin/abc')
386        self.assertEqual(filter_url(
387            'http://domain.com/admin/default/abc', out=True), '/admin/abc')
388        # incoming
389        self.assertRaises(HTTP, filter_url, 'http://domain.com')
390        self.assertRaises(HTTP, filter_url, 'http://domain.com/appadmin')
391        self.myassertRaisesRegex(HTTP, "400.*invalid function",
392                                filter_url, 'http://domain.com')
393        self.myassertRaisesRegex(HTTP, "400.*unknown application: 'appadmin'", filter_url, 'http://domain.com/appadmin')
394
395    def test_router_app(self):
396        """ Tests the doctest router app resolution"""
397        routers = dict(
398            BASE=dict(
399                domains={
400                    "domain1.com": "app1",
401                    "www.domain1.com": "app1",
402                    "domain2.com": "app2",
403                },
404            ),
405            app1=dict(),
406            app2=dict(),
407            goodapp=dict(),
408        )
409        routers['bad!app'] = dict()
410        load(rdict=routers)
411        self.assertEqual(
412            filter_url('http://domain.com/welcome', app=True), 'welcome')
413        self.assertEqual(
414            filter_url('http://domain.com/welcome/', app=True), 'welcome')
415        self.assertEqual(filter_url('http://domain.com', app=True), 'init')
416        self.assertEqual(filter_url('http://domain.com/', app=True), 'init')
417        self.assertEqual(filter_url('http://domain.com/abc', app=True), 'init')
418        self.assertEqual(
419            filter_url('http://domain1.com/abc', app=True), 'app1')
420        self.assertEqual(
421            filter_url('http://www.domain1.com/abc', app=True), 'app1')
422        self.assertEqual(
423            filter_url('http://domain2.com/abc', app=True), 'app2')
424        self.assertEqual(
425            filter_url('http://domain2.com/admin', app=True), 'admin')
426
427        routers['BASE']['exclusive_domain'] = True
428        load(rdict=routers)
429        self.assertEqual(
430            filter_url('http://domain2.com/admin', app=True), 'app2')
431
432        self.assertEqual(
433            filter_url('http://domain.com/goodapp', app=True), 'goodapp')
434        self.assertRaises(
435            HTTP, filter_url, 'http://domain.com/bad!app', app=True)
436        self.myassertRaisesRegex(HTTP, '400.*invalid application',
437                                    filter_url, 'http://domain.com/bad!app')
438
439        routers['BASE']['domains']['domain3.com'] = 'app3'
440        self.assertRaises(SyntaxError, load, rdict=routers)
441        self.myassertRaisesRegex(
442                SyntaxError, "unknown.*app3", load, rdict=routers)
443
444    def test_router_domains_fs(self):
445        '''
446        Test URLs that map domains using test filesystem layout
447        '''
448        routers = dict(
449            BASE=dict(
450                domains={
451                    "domain1.com": "admin",
452                    "domain2.com": "welcome",
453                },
454            ),
455        )
456
457        load(rdict=routers)
458        self.assertEqual(
459            filter_url('http://domain1.com'), '/admin/default/index')
460        self.assertEqual(
461            filter_url('http://domain2.com'), '/welcome/default/index')
462        self.assertEqual(
463            filter_url('http://domain1.com/gae'), '/admin/gae/index')
464        self.assertEqual(
465            filter_url('http://domain2.com/other'), '/welcome/other/index')
466        self.assertEqual(
467            filter_url('http://domain1.com/gae/f1'), '/admin/gae/f1')
468        self.assertEqual(
469            filter_url('http://domain2.com/f2'), '/welcome/default/f2')
470        self.assertEqual(
471            filter_url('http://domain2.com/other/f3'), '/welcome/other/f3')
472
473    def test_router_domains(self):
474        '''
475        Test URLs that map domains
476        '''
477        routers = dict(
478            BASE=dict(
479                applications=['app1', 'app2', 'app2A',
480                              'app3', 'app4', 'app5', 'app6'],
481                domains={
482                    #  two domains to the same app
483                    "domain1.com": "app1",
484                    "www.domain1.com": "app1",
485                    #  same domain, two ports, to two apps
486                    "domain2.com": "app2a",
487                    "domain2.com:8080": "app2b",
488                    #  two domains, same app, two controllers
489                    "domain3a.com": "app3/c3a",
490                    "domain3b.com": "app3/c3b",
491                    #  two domains, same app & controller, two functions
492                    "domain4a.com": "app4/c4/f4a",
493                    "domain4b.com": "app4/c4/f4b",
494                    #  http vs https
495                    "domain6.com:80": "app6",
496                    "domain6.com:443": "app6s",
497                },
498            ),
499            app1=dict(default_controller='c1', default_function='f1',
500                      controllers=['c1'], exclusive_domain=True, ),
501            app2a=dict(default_controller='c2a',
502                       default_function='f2a', controllers=['c2a'], ),
503            app2b=dict(default_controller='c2b',
504                       default_function='f2b', controllers=['c2b'], ),
505            app3=dict(controllers=['c3a', 'c3b'], ),
506            app4=dict(default_controller='c4', controllers=['c4']),
507            app5=dict(default_controller='c5',
508                      controllers=['c5'], domain='localhost'),
509            app6=dict(default_controller='c6',
510                      default_function='f6', controllers=['c6'], ),
511            app6s=dict(default_controller='c6s',
512                       default_function='f6s', controllers=['c6s'], ),
513        )
514
515        load(rdict=routers)
516        self.assertEqual(filter_url('http://domain1.com/abc'), '/app1/c1/abc')
517        self.assertEqual(
518            filter_url('http://domain1.com/c1/abc'), '/app1/c1/abc')
519        self.assertEqual(
520            filter_url('http://domain1.com/abc.html'), '/app1/c1/abc')
521        self.assertEqual(
522            filter_url('http://domain1.com/abc.css'), '/app1/c1/abc.css')
523        self.assertEqual(filter_url(
524            'http://domain1.com/index/abc'), "/app1/c1/index ['abc']")
525        self.assertEqual(filter_url('http://domain2.com/app1'), "/app1/c1/f1")
526
527        self.assertEqual(filter_url('https://domain1.com/app1/ctr/fcn',
528                         domain=('app1', None), out=True), "/ctr/fcn")
529        self.assertEqual(filter_url('https://www.domain1.com/app1/ctr/fcn',
530                         domain=('app1', None), out=True), "/ctr/fcn")
531
532        self.assertEqual(
533            filter_url('http://domain2.com/abc'), '/app2a/c2a/abc')
534        self.assertEqual(
535            filter_url('http://domain2.com:8080/abc'), '/app2b/c2b/abc')
536
537        self.assertEqual(filter_url('http://domain2.com/app2a/ctr/fcn',
538                         domain=('app2a', None), out=True), "/ctr/fcn")
539        self.assertEqual(filter_url('http://domain2.com/app2a/ctr/f2a',
540                         domain=('app2a', None), out=True), "/ctr")
541        self.assertEqual(filter_url('http://domain2.com/app2a/c2a/f2a',
542                         domain=('app2a', None), out=True), "/")
543        self.assertEqual(filter_url('http://domain2.com/app2a/c2a/fcn',
544                         domain=('app2a', None), out=True), "/fcn")
545        self.assertEqual(filter_url('http://domain2.com/app2a/ctr/fcn',
546                         domain=('app2b', None), out=True), "/app2a/ctr/fcn")
547        self.assertEqual(filter_url('http://domain2.com/app2a/ctr/f2a',
548                         domain=('app2b', None), out=True), "/app2a/ctr")
549        self.assertEqual(filter_url('http://domain2.com/app2a/c2a/f2a',
550                         domain=('app2b', None), out=True), "/app2a")
551
552        self.assertEqual(filter_url('http://domain3a.com/'), '/app3/c3a/index')
553        self.assertEqual(
554            filter_url('http://domain3a.com/abc'), '/app3/c3a/abc')
555        self.assertEqual(
556            filter_url('http://domain3a.com/c3b'), '/app3/c3b/index')
557        self.assertEqual(
558            filter_url('http://domain3b.com/abc'), '/app3/c3b/abc')
559
560        self.assertEqual(filter_url('http://domain3a.com/app3/c3a/fcn',
561                         domain=('app3', 'c3a'), out=True), "/fcn")
562        self.assertEqual(filter_url('http://domain3a.com/app3/c3a/fcn',
563                         domain=('app3', 'c3b'), out=True), "/c3a/fcn")
564        self.assertEqual(filter_url('http://domain3a.com/app3/c3a/fcn',
565                         domain=('app1', None), out=True), "/app3/c3a/fcn")
566
567        self.assertEqual(filter_url('http://domain4a.com/abc'), '/app4/c4/abc')
568        self.assertEqual(filter_url('https://domain4a.com/app4/c4/fcn',
569                         domain=('app4', None), out=True), "/fcn")
570
571        self.assertEqual(filter_url('http://domain4a.com'), '/app4/c4/f4a')
572        self.assertEqual(filter_url('http://domain4b.com'), '/app4/c4/f4b')
573
574        self.assertEqual(filter_url('http://localhost/abc'), '/app5/c5/abc')
575        self.assertEqual(filter_url(
576            'http:///abc'), '/app5/c5/abc')  # test null host => localhost
577        self.assertEqual(filter_url('https://localhost/app5/c5/fcn',
578                         domain=('app5', None), out=True), "/fcn")
579
580        self.assertEqual(filter_url('http://domain6.com'), '/app6/c6/f6')
581        self.assertEqual(filter_url('https://domain6.com'), '/app6s/c6s/f6s')
582
583        self.assertEqual(filter_url('http://domain2.com/app3/c3a/f3',
584                         domain=('app2b', None), out=True), "/app3/c3a/f3")
585        self.assertRaises(SyntaxError, filter_url, 'http://domain1.com/app1/c1/f1', domain=('app2b', None), out=True)
586        self.myassertRaisesRegex(SyntaxError, 'cross-domain conflict', filter_url,
587                                 'http://domain1.com/app1/c1/f1', domain=('app2b', None), out=True)
588        self.assertEqual(filter_url('http://domain1.com/app1/c1/f1', domain=(
589            'app2b', None), host='domain2.com', out=True), "/app1")
590
591    def test_router_domains_ed(self):
592        '''
593        Test URLs that map domains with exclusive_domain set
594        '''
595        routers = dict(
596            BASE=dict(
597                applications=['app1', 'app2', 'app2A',
598                              'app3', 'app4', 'app5', 'app6'],
599                exclusive_domain=True,
600                domains={
601                    #  two domains to the same app
602                    "domain1.com": "app1",
603                    "www.domain1.com": "app1",
604                    #  same domain, two ports, to two apps
605                    "domain2.com": "app2a",
606                    "domain2.com:8080": "app2b",
607                    #  two domains, same app, two controllers
608                    "domain3a.com": "app3/c3a",
609                    "domain3b.com": "app3/c3b",
610                    #  two domains, same app & controller, two functions
611                    "domain4a.com": "app4/c4/f4a",
612                    "domain4b.com": "app4/c4/f4b",
613                    #  http vs https
614                    "domain6.com:80": "app6",
615                    "domain6.com:443": "app6s",
616                },
617            ),
618            app1=dict(default_controller='c1', default_function='f1',
619                      controllers=['c1'], exclusive_domain=True, ),
620            app2a=dict(default_controller='c2a',
621                       default_function='f2a', controllers=['c2a'], ),
622            app2b=dict(default_controller='c2b',
623                       default_function='f2b', controllers=['c2b'], ),
624            app3=dict(controllers=['c3a', 'c3b'], ),
625            app4=dict(default_controller='c4', controllers=['c4']),
626            app5=dict(default_controller='c5',
627                      controllers=['c5'], domain='localhost'),
628            app6=dict(default_controller='c6',
629                      default_function='f6', controllers=['c6'], ),
630            app6s=dict(default_controller='c6s',
631                       default_function='f6s', controllers=['c6s'], ),
632        )
633
634        load(rdict=routers)
635        self.assertEqual(filter_url('http://domain1.com/abc'), '/app1/c1/abc')
636        self.assertEqual(
637            filter_url('http://domain1.com/c1/abc'), '/app1/c1/abc')
638        self.assertEqual(
639            filter_url('http://domain1.com/abc.html'), '/app1/c1/abc')
640        self.assertEqual(
641            filter_url('http://domain1.com/abc.css'), '/app1/c1/abc.css')
642        self.assertEqual(filter_url(
643            'http://domain1.com/index/abc'), "/app1/c1/index ['abc']")
644        self.assertEqual(
645            filter_url('http://domain2.com/app1'), "/app2a/c2a/app1")
646
647        self.assertEqual(filter_url('https://domain1.com/app1/ctr/fcn',
648                         domain=('app1', None), out=True), "/ctr/fcn")
649        self.assertEqual(filter_url('https://www.domain1.com/app1/ctr/fcn',
650                         domain=('app1', None), out=True), "/ctr/fcn")
651
652        self.assertEqual(
653            filter_url('http://domain2.com/abc'), '/app2a/c2a/abc')
654        self.assertEqual(
655            filter_url('http://domain2.com:8080/abc'), '/app2b/c2b/abc')
656
657        self.assertEqual(filter_url('http://domain2.com/app2a/ctr/fcn',
658                         domain=('app2a', None), out=True), "/ctr/fcn")
659        self.assertEqual(filter_url('http://domain2.com/app2a/ctr/f2a',
660                         domain=('app2a', None), out=True), "/ctr")
661        self.assertEqual(filter_url('http://domain2.com/app2a/c2a/f2a',
662                         domain=('app2a', None), out=True), "/")
663        self.assertEqual(filter_url('http://domain2.com/app2a/c2a/fcn',
664                         domain=('app2a', None), out=True), "/fcn")
665
666        self.assertRaises(SyntaxError, filter_url, 'http://domain2.com/app2a/ctr/fcn', domain=('app2b', None), out=True)
667        self.assertRaises(SyntaxError, filter_url, 'http://domain2.com/app2a/ctr/f2a', domain=('app2b', None), out=True)
668        self.assertRaises(SyntaxError, filter_url, 'http://domain2.com/app2a/c2a/f2a', domain=('app2b', None), out=True)
669
670        self.assertEqual(filter_url('http://domain3a.com/'), '/app3/c3a/index')
671        self.assertEqual(
672            filter_url('http://domain3a.com/abc'), '/app3/c3a/abc')
673        self.assertEqual(
674            filter_url('http://domain3a.com/c3b'), '/app3/c3b/index')
675        self.assertEqual(
676            filter_url('http://domain3b.com/abc'), '/app3/c3b/abc')
677
678        self.assertEqual(filter_url('http://domain3a.com/app3/c3a/fcn',
679                         domain=('app3', 'c3a'), out=True), "/fcn")
680        self.assertEqual(filter_url('http://domain3a.com/app3/c3a/fcn',
681                         domain=('app3', 'c3b'), out=True), "/c3a/fcn")
682
683        self.assertRaises(SyntaxError, filter_url, 'http://domain3a.com/app3/c3a/fcn', domain=('app1', None), out=True)
684
685        self.assertEqual(filter_url('http://domain4a.com/abc'), '/app4/c4/abc')
686        self.assertEqual(filter_url('https://domain4a.com/app4/c4/fcn',
687                         domain=('app4', None), out=True), "/fcn")
688
689        self.assertEqual(filter_url('http://domain4a.com'), '/app4/c4/f4a')
690        self.assertEqual(filter_url('http://domain4b.com'), '/app4/c4/f4b')
691
692        self.assertEqual(filter_url('http://localhost/abc'), '/app5/c5/abc')
693        self.assertEqual(filter_url(
694            'http:///abc'), '/app5/c5/abc')  # test null host => localhost
695        self.assertEqual(filter_url('https://localhost/app5/c5/fcn',
696                         domain=('app5', None), out=True), "/fcn")
697
698        self.assertEqual(filter_url('http://domain6.com'), '/app6/c6/f6')
699        self.assertEqual(filter_url('https://domain6.com'), '/app6s/c6s/f6s')
700
701        self.assertRaises(SyntaxError, filter_url, 'http://domain2.com/app3/c3a/f3', domain=('app2b', None), out=True)
702        self.assertRaises(SyntaxError, filter_url, 'http://domain1.com/app1/c1/f1', domain=('app2b', None), out=True)
703        self.myassertRaisesRegex(SyntaxError, 'cross-domain conflict', filter_url,
704                                 'http://domain1.com/app1/c1/f1', domain=('app2b', None), out=True)
705        self.assertEqual(filter_url('http://domain1.com/app1/c1/f1', domain=(
706            'app2b', None), host='domain2.com', out=True), "/app1")
707
708    def test_router_raise(self):
709        '''
710        Test URLs that raise exceptions
711        '''
712        # test non-exception variants
713        router_raise = dict(
714            init=dict(
715                controllers=[],
716            ),
717            welcome=dict(
718                map_hyphen=False,
719            ),
720        )
721        load(rdict=router_raise)
722        self.assertEqual(
723            filter_url('http://domain.com/ctl'), "/init/ctl/index")
724        self.assertEqual(
725            filter_url('http://domain.com/default/fcn'), "/init/default/fcn")
726        self.assertEqual(filter_url(
727            'http://domain.com/default/fcn.ext'), "/init/default/fcn.ext")
728        self.assertEqual(filter_url('http://domain.com/default/fcn/arg'),
729                         "/init/default/fcn ['arg']")
730        # now raise-HTTP variants
731        self.assertRaises(HTTP, filter_url, 'http://domain.com/bad!ctl')
732        self.assertRaises(HTTP, filter_url, 'http://domain.com/ctl/bad!fcn')
733        self.assertRaises(
734            HTTP, filter_url, 'http://domain.com/ctl/fcn.bad!ext')
735        self.assertRaises(
736            HTTP, filter_url, 'http://domain.com/ctl/fcn/bad!arg')
737        self.myassertRaisesRegex(HTTP, '400.*invalid controller', filter_url, 'http://domain.com/init/bad!ctl')
738        self.myassertRaisesRegex(HTTP, '400.*invalid function', filter_url,
739                                'http://domain.com/init/ctlr/bad!fcn')
740        self.myassertRaisesRegex(HTTP, '400.*invalid extension', filter_url,
741                                'http://domain.com/init/ctlr/fcn.bad!ext')
742        self.myassertRaisesRegex(HTTP, '400.*invalid arg', filter_url,
743                                'http://domain.com/appc/init/fcn/bad!arg')
744
745        self.assertEqual(filter_url('http://domain.com/welcome/default/fcn_1'),
746                         "/welcome/default/fcn_1")
747        self.assertRaises(
748            HTTP, filter_url, 'http://domain.com/welcome/default/fcn-1')
749        self.myassertRaisesRegex(HTTP, '400.*invalid function', filter_url,
750                                    'http://domain.com/welcome/default/fcn-1')
751
752    def test_router_out(self):
753        '''
754        Test basic outgoing routing
755        '''
756        router_out = dict(
757            BASE=dict(),
758            init=dict(controllers=['default', 'ctr'], ),
759            app=dict(),
760        )
761        load(rdict=router_out)
762        self.assertEqual(filter_url(
763            'https://domain.com/app/ctr/fcn', out=True), "/app/ctr/fcn")
764        self.assertEqual(filter_url(
765            'https://domain.com/init/ctr/fcn', out=True), "/ctr/fcn")
766        self.assertEqual(filter_url(
767            'https://domain.com/init/ctr/fcn', out=True), "/ctr/fcn")
768        self.assertEqual(filter_url('https://domain.com/init/static/file',
769                         out=True), "/init/static/file")
770        self.assertEqual(filter_url('https://domain.com/init/static/index',
771                         out=True), "/init/static/index")
772        self.assertEqual(filter_url(
773            'https://domain.com/init/default/index', out=True), "/")
774        self.assertEqual(
775            filter_url('https://domain.com/init/ctr/index', out=True), "/ctr")
776        self.assertEqual(filter_url('http://domain.com/init/default/fcn?query',
777                         out=True), "/fcn?query")
778        self.assertEqual(filter_url('http://domain.com/init/default/fcn#anchor', out=True), "/fcn#anchor")
779        self.assertEqual(
780            filter_url(
781                'http://domain.com/init/default/fcn?query#anchor', out=True),
782            "/fcn?query#anchor")
783
784        router_out['BASE']['map_static'] = True
785        load(rdict=router_out)
786        self.assertEqual(filter_url(
787            'https://domain.com/init/static/file', out=True), "/static/file")
788        self.assertEqual(filter_url('https://domain.com/init/static/index',
789                         out=True), "/static/index")
790
791        router_out['init']['map_static'] = None
792        load(rdict=router_out)
793        self.assertEqual(filter_url('https://domain.com/init/static/file',
794                         out=True), "/init/static/file")
795        self.assertEqual(filter_url('https://domain.com/init/static/index',
796                         out=True), "/init/static/index")
797
798    def test_router_functions(self):
799        '''
800        Test function-omission with functions=[something]
801        '''
802        router_functions = dict(
803            BASE=dict(
804                applications=['init', 'app', 'app2'],
805                default_application='app',
806            ),
807            init=dict(
808                controllers=['default'],
809            ),
810            app=dict(
811                controllers=['default', 'ctr'],
812                functions=dict(
813                    default=['index', 'user', 'help'],
814                    ctr=['ctrf1', 'ctrf2', 'ctrf3'],
815                ),
816                default_function=dict(
817                    default='index',
818                    ctr='ctrf1',
819                ),
820            ),
821            app2=dict(
822                controllers=['default', 'ctr'],
823                functions=['index', 'user', 'help'],
824            ),
825        )
826        load(rdict=router_functions)
827
828        # outbound
829        self.assertEqual(str(
830            URL(a='init', c='default', f='f', args=['arg1'])), "/init/f/arg1")
831        self.assertEqual(str(URL(a='init', c='default', f='index',
832                         args=['arg1'])), "/init/index/arg1")
833
834        self.assertEqual(
835            str(URL(a='app', c='default', f='index', args=['arg1'])), "/arg1")
836        self.assertEqual(str(
837            URL(a='app', c='default', f='user', args=['arg1'])), "/user/arg1")
838        self.assertEqual(str(URL(
839            a='app', c='default', f='user', args=['index'])), "/user/index")
840        self.assertEqual(str(URL(
841            a='app', c='default', f='index', args=['index'])), "/index/index")
842        self.assertEqual(str(URL(
843            a='app', c='default', f='index', args=['init'])), "/index/init")
844        self.assertEqual(str(
845            URL(a='app', c='default', f='index', args=['ctr'])), "/index/ctr")
846        self.assertEqual(str(
847            URL(a='app', c='ctr', f='index', args=['arg'])), "/ctr/index/arg")
848        self.assertEqual(
849            str(URL(a='app', c='ctr', f='ctrf1', args=['arg'])), "/ctr/arg")
850        self.assertEqual(str(URL(
851            a='app', c='ctr', f='ctrf1', args=['ctrf2'])), "/ctr/ctrf1/ctrf2")
852
853        self.assertEqual(str(URL(
854            a='app2', c='default', f='index', args=['arg1'])), "/app2/arg1")
855        self.assertEqual(str(URL(a='app2', c='default', f='user',
856                         args=['arg1'])), "/app2/user/arg1")
857        self.assertEqual(str(URL(a='app2', c='default', f='user',
858                         args=['index'])), "/app2/user/index")
859        self.assertEqual(str(URL(a='app2', c='default', f='index',
860                         args=['index'])), "/app2/index/index")
861        self.assertEqual(str(URL(a='app2', c='default', f='index',
862                         args=['init'])), "/app2/index/init")
863        self.assertEqual(str(URL(a='app2', c='default', f='index',
864                         args=['ctr'])), "/app2/index/ctr")
865
866        # outbound - with extensions
867        self.assertEqual(
868            str(URL(a='app', c='default', f='index.json')), "/index.json")
869        self.assertEqual(
870            str(URL(a='app', c='default', f='index.json', args=['arg1'])), "/index.json/arg1")
871        self.assertEqual(str(
872            URL(a='app', c='default', f='user.json')), "/user.json")
873        self.assertEqual(str(
874            URL(a='app', c='default', f='user.json', args=['arg1'])), "/user.json/arg1")
875        self.assertEqual(str(URL(
876            a='app', c='default', f='user.json', args=['index'])), "/user.json/index")
877        self.assertEqual(str(
878            URL(a='app', c='default', f='index.json', args=['ctr'])), "/index.json/ctr")
879        self.assertEqual(
880            str(URL(a='app', c='ctr', f='ctrf1.json', args=['arg'])), "/ctr/ctrf1.json/arg")
881
882        self.assertEqual(str(URL(
883            a='app2', c='default', f='index.json', args=['arg1'])), "/app2/index.json/arg1")
884        self.assertEqual(str(URL(
885            a='app2', c='ctr', f='index.json', args=['arg1'])), "/app2/ctr/index.json/arg1")
886
887        # inbound
888        self.assertEqual(
889            filter_url('http://d.com/arg'), "/app/default/index ['arg']")
890        self.assertEqual(filter_url('http://d.com/user'), "/app/default/user")
891        self.assertEqual(
892            filter_url('http://d.com/user/arg'), "/app/default/user ['arg']")
893        self.assertEqual(filter_url('http://d.com/ctr'), "/app/ctr/ctrf1")
894        self.assertEqual(
895            filter_url('http://d.com/ctr/arg'), "/app/ctr/ctrf1 ['arg']")
896
897        self.assertEqual(filter_url(
898            'http://d.com/app2/arg'), "/app2/default/index ['arg']")
899        self.assertEqual(
900            filter_url('http://d.com/app2/user'), "/app2/default/user")
901        self.assertEqual(filter_url(
902            'http://d.com/app2/user/arg'), "/app2/default/user ['arg']")
903        self.assertEqual(
904            filter_url('http://d.com/app2/ctr'), "/app2/ctr/index")
905        self.assertEqual(filter_url(
906            'http://d.com/app2/ctr/index/arg'), "/app2/ctr/index ['arg']")
907        self.assertEqual(
908            filter_url('http://d.com/app2/ctr/arg'), "/app2/ctr/arg")
909
910        # inbound - with extensions
911        self.assertEqual(
912            filter_url('http://d.com/index.json'), "/app/default/index.json")
913        self.assertEqual(filter_url('http://d.com/user.json'), "/app/default/user.json")
914        self.assertEqual(
915            filter_url('http://d.com/user.json/arg'), "/app/default/user.json ['arg']")
916        self.assertEqual(
917            filter_url('http://d.com/user.json/index'), "/app/default/user.json ['index']")
918        self.assertEqual(
919            filter_url('http://d.com/index.json/ctr'), "/app/default/index.json ['ctr']")
920        self.assertEqual(
921            filter_url('http://d.com/ctr/ctrf1.json/arg'), "/app/ctr/ctrf1.json ['arg']")
922
923        self.assertEqual(filter_url(
924            'http://d.com/app2/index.json/arg'), "/app2/default/index.json ['arg']")
925        self.assertEqual(
926            filter_url('http://d.com/app2/user.json'), "/app2/default/user.json")
927        self.assertEqual(filter_url(
928            'http://d.com/app2/user.json/arg'), "/app2/default/user.json ['arg']")
929        self.assertEqual(filter_url(
930            'http://d.com/app2/ctr/index.json/arg'), "/app2/ctr/index.json ['arg']")
931        self.assertEqual(
932            filter_url('http://d.com/app2/ctr/arg'), "/app2/ctr/arg")
933
934    def test_router_functions2(self):
935        '''
936        Test more functions=[something]
937        '''
938        router_functions = dict(
939            BASE=dict(
940                default_application='init',
941                applications='INIT',
942            ),
943            init=dict(
944                #default_controller = 'default',
945                controllers=['default', 'ctr'],
946                #default_function = 'index',
947                functions=['index', 'user', 'register', 'basicRegister',
948                           'download', 'call', 'data', 'error']
949            ),
950        )
951
952        load(rdict=router_functions)
953
954        # outbound
955        self.assertEqual(str(
956            URL(a='init', c='default', f='index', args=['arg1'])), "/arg1")
957        self.assertEqual(str(URL(
958            a='init', c='default', f='user', args=['arg1'])), "/user/arg1")
959        self.assertEqual(str(URL(
960            a='init', c='default', f='user', args=['index'])), "/user/index")
961        self.assertEqual(str(URL(a='init', c='default', f='index',
962                         args=['index'])), "/index/index")
963        self.assertEqual(str(
964            URL(a='init', c='default', f='index', args=['init'])), "/init")
965        self.assertEqual(str(URL(
966            a='init', c='default', f='index', args=['ctr'])), "/index/ctr")
967        self.assertEqual(str(URL(
968            a='init', c='ctr', f='index', args=['arg'])), "/ctr/index/arg")
969        self.assertEqual(str(URL(
970            a='init', c='ctr', f='ctrf1', args=['arg'])), "/ctr/ctrf1/arg")
971        self.assertEqual(str(URL(a='init', c='ctr', f='ctrf1',
972                         args=['ctrf2'])), "/ctr/ctrf1/ctrf2")
973        self.assertEqual(
974            str(URL(a='init', c='default', f='register')), "/register")
975
976        # inbound
977        self.assertEqual(
978            filter_url('http://d.com/arg'), "/init/default/index ['arg']")
979        self.assertEqual(filter_url('http://d.com/user'), "/init/default/user")
980        self.assertEqual(
981            filter_url('http://d.com/user/arg'), "/init/default/user ['arg']")
982        self.assertEqual(filter_url('http://d.com/ctr'), "/init/ctr/index")
983        self.assertEqual(filter_url(
984            'http://d.com/ctr/ctrf1/arg'), "/init/ctr/ctrf1 ['arg']")
985
986    def test_router_hyphen(self):
987        '''
988        Test hyphen conversion
989        '''
990        router_hyphen = dict(
991            BASE=dict(
992                applications=['init', 'app1', 'app2'],
993            ),
994            init=dict(
995                controllers=['default'],
996            ),
997            app1=dict(
998                controllers=['default'],
999                map_hyphen=True,
1000            ),
1001            app2=dict(
1002                controllers=['default'],
1003                map_hyphen=False,
1004            ),
1005        )
1006        load(rdict=router_hyphen)
1007        self.assertEqual(filter_url(
1008            'http://domain.com/init/default/fcn_1', out=True), "/fcn_1")
1009        self.assertEqual(
1010            filter_url('http://domain.com/static/filename-with_underscore'),
1011            norm_root("%s/applications/init/static/filename-with_underscore" % root))
1012        self.assertEqual(
1013            filter_url('http://domain.com/init/static/filename-with_underscore', out=True),
1014            "/init/static/filename-with_underscore")
1015
1016        self.assertEqual(filter_url('http://domain.com/app2/fcn_1'),
1017                         "/app2/default/fcn_1")
1018        self.assertEqual(
1019            filter_url('http://domain.com/app2/ctr/fcn_1',
1020                       domain=('app2', None), out=True),
1021            "/ctr/fcn_1")
1022        self.assertEqual(
1023            filter_url('http://domain.com/app2/static/filename-with_underscore', domain=('app2', None), out=True),
1024            "/app2/static/filename-with_underscore")
1025        self.assertEqual(
1026            filter_url(
1027                'http://domain.com/app2/static/filename-with_underscore'),
1028            norm_root("%s/applications/app2/static/filename-with_underscore" % root))
1029
1030        self.assertEqual(str(URL(a='init', c='default', f='a_b')), "/a_b")
1031        self.assertEqual(str(URL(a='app1', c='default', f='a_b')), "/app1/a-b")
1032        self.assertEqual(str(URL(a='app2', c='default', f='a_b')), "/app2/a_b")
1033
1034        from gluon.globals import current
1035        if hasattr(current, 'response'):
1036            current.response.static_version = None
1037
1038        self.assertEqual(
1039            str(URL(a='app1', c='static', f='a/b_c')), "/app1/static/a/b_c")
1040        self.assertEqual(
1041            str(URL(a='app1', c='static/a', f='b_c')), "/app1/static/a/b_c")
1042        self.assertEqual(
1043            str(URL(a='app2', c='static', f='a/b_c')), "/app2/static/a/b_c")
1044        self.assertEqual(
1045            str(URL(a='app2', c='static/a', f='b_c')), "/app2/static/a/b_c")
1046
1047    def test_router_lang(self):
1048        '''
1049        Test language specifications
1050        '''
1051        router_lang = dict(
1052            BASE=dict(default_application='admin'),
1053            welcome=dict(),
1054            admin=dict(
1055                controllers=['default', 'ctr'],
1056                languages=['en', 'it', 'it-it'], default_language='en',
1057            ),
1058            examples=dict(
1059                languages=['en', 'it', 'it-it'], default_language='en',
1060            ),
1061        )
1062        load(rdict=router_lang)
1063        self.assertEqual(filter_url('http://domain.com/index/abc'),
1064                         "/admin/default/index ['abc'] (en)")
1065        self.assertEqual(filter_url('http://domain.com/en/abc/def'),
1066                         "/admin/default/abc ['def'] (en)")
1067        self.assertEqual(filter_url('http://domain.com/it/abc/def'),
1068                         "/admin/default/abc ['def'] (it)")
1069        self.assertEqual(filter_url('http://domain.com/it-it/abc/def'),
1070                         "/admin/default/abc ['def'] (it-it)")
1071        self.assertEqual(filter_url('http://domain.com/index/a%20bc'),
1072                         "/admin/default/index ['a bc'] (en)")
1073        self.assertEqual(filter_url('http://domain.com/static/file'),
1074                        norm_root("%s/applications/admin/static/file" % root))
1075        self.assertEqual(filter_url('http://domain.com/en/static/file'),
1076                        norm_root("%s/applications/admin/static/file" % root))
1077        self.assertEqual(filter_url('http://domain.com/examples/en/static/file'),
1078                        norm_root("%s/applications/examples/static/en/file" % root))
1079        self.assertEqual(filter_url('http://domain.com/examples/static/file'),
1080                         norm_root("%s/applications/examples/static/en/file" % root))
1081        self.assertEqual(filter_url('http://domain.com/examples/it/static/file'),
1082                        norm_root("%s/applications/examples/static/it/file" % root))
1083        self.assertEqual(filter_url('http://domain.com/examples/it-it/static/file'),
1084                        norm_root("%s/applications/examples/static/file" % root))
1085
1086        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1087                         lang='en', out=True), "/ctr/fcn")
1088        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1089                         lang='it', out=True), "/it/ctr/fcn")
1090        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1091                         lang='it-it', out=True), "/it-it/ctr/fcn")
1092        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1093                         lang='en', out=True), "/admin/en/static/file")
1094        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1095                         lang='it', out=True), "/admin/it/static/file")
1096        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1097                         lang='it-it', out=True), "/admin/it-it/static/file")
1098        self.assertEqual(filter_url('https://domain.com/welcome/ctr/fcn',
1099                         lang='it', out=True), "/welcome/ctr/fcn")
1100        self.assertEqual(filter_url('https://domain.com/welcome/ctr/fcn',
1101                         lang='es', out=True), "/welcome/ctr/fcn")
1102
1103        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1104                         language='en', out=True), "/ctr/fcn")
1105        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1106                         language='it', out=True), "/it/ctr/fcn")
1107        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1108                         language='it-it', out=True), "/it-it/ctr/fcn")
1109        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1110                         language='en', out=True), "/admin/en/static/file")
1111        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1112                         language='it', out=True), "/admin/it/static/file")
1113        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1114                         language='it-it', out=True), "/admin/it-it/static/file")
1115        self.assertEqual(filter_url('https://domain.com/welcome/ctr/fcn',
1116                         language='it', out=True), "/welcome/ctr/fcn")
1117        self.assertEqual(filter_url('https://domain.com/welcome/ctr/fcn',
1118                         language='es', out=True), "/welcome/ctr/fcn")
1119
1120        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1121                         lang='it', language='en', out=True), "/ctr/fcn")
1122        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1123                         lang='en', language='it', out=True), "/it/ctr/fcn")
1124        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1125                         lang='it', language='it-it', out=True), "/it-it/ctr/fcn")
1126        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1127                         lang='it', language='en', out=True), "/admin/en/static/file")
1128        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1129                         lang='it', language='it', out=True), "/admin/it/static/file")
1130        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1131                         lang='it', language='it-it', out=True), "/admin/it-it/static/file")
1132        self.assertEqual(filter_url('https://domain.com/welcome/ctr/fcn',
1133                         lang='it', language='it', out=True), "/welcome/ctr/fcn")
1134        self.assertEqual(filter_url('https://domain.com/welcome/ctr/fcn',
1135                         lang='it', language='es', out=True), "/welcome/ctr/fcn")
1136
1137        router_lang['admin']['map_static'] = True
1138        load(rdict=router_lang)
1139        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1140                         lang='en', out=True), "/ctr/fcn")
1141        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1142                         lang='it', out=True), "/it/ctr/fcn")
1143        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1144                         lang='it-it', out=True), "/it-it/ctr/fcn")
1145        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1146                         lang='en', out=True), "/static/file")
1147        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1148                         lang='it', out=True), "/it/static/file")
1149        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1150                         lang='it-it', out=True), "/it-it/static/file")
1151        self.assertEqual(filter_url('https://domain.com/welcome/ctr/fcn',
1152                         lang='it', out=True), "/welcome/ctr/fcn")
1153        self.assertEqual(filter_url('https://domain.com/welcome/ctr/fcn',
1154                         lang='es', out=True), "/welcome/ctr/fcn")
1155
1156        router_lang['admin']['map_static'] = False
1157        router_lang['examples']['map_static'] = False
1158        load(rdict=router_lang)
1159        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1160                         lang='en', out=True), "/ctr/fcn")
1161        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1162                         lang='it', out=True), "/it/ctr/fcn")
1163        self.assertEqual(filter_url('https://domain.com/admin/ctr/fcn',
1164                         lang='it-it', out=True), "/it-it/ctr/fcn")
1165        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1166                         lang='en', out=True), "/admin/static/en/file")
1167        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1168                         lang='it', out=True), "/admin/static/it/file")
1169        self.assertEqual(filter_url('https://domain.com/admin/static/file',
1170                         lang='it-it', out=True), "/admin/static/it-it/file")
1171        self.assertEqual(filter_url('https://domain.com/welcome/ctr/fcn',
1172                         lang='it', out=True), "/welcome/ctr/fcn")
1173        self.assertEqual(filter_url('https://domain.com/welcome/ctr/fcn',
1174                         lang='es', out=True), "/welcome/ctr/fcn")
1175        self.assertEqual(filter_url('http://domain.com/static/file'),
1176                         norm_root("%s/applications/admin/static/file" % root))
1177        self.assertEqual(filter_url('http://domain.com/en/static/file'),
1178                         norm_root("%s/applications/admin/static/file" % root))
1179        self.assertEqual(filter_url('http://domain.com/examples/en/static/file'),
1180                        norm_root("%s/applications/examples/static/en/file" % root))
1181        self.assertEqual(filter_url('http://domain.com/examples/static/file'),
1182                        norm_root("%s/applications/examples/static/en/file" % root))
1183        self.assertEqual(filter_url('http://domain.com/examples/it/static/file'),
1184                        norm_root("%s/applications/examples/static/it/file" % root))
1185        self.assertEqual(filter_url('http://domain.com/examples/it-it/static/file'),
1186                        norm_root("%s/applications/examples/static/file" % root))
1187        self.assertEqual(filter_url('http://domain.com/examples/static/en/file').replace('/', os.sep),
1188                        norm_root("%s/applications/examples/static/en/file" % root))
1189        self.assertEqual(filter_url('http://domain.com/examples/static/it/file').replace('/', os.sep),
1190                        norm_root("%s/applications/examples/static/it/file" % root))
1191        self.assertEqual(filter_url('http://domain.com/examples/static/it-it/file').replace('/', os.sep),
1192                        norm_root("%s/applications/examples/static/it-it/file" % root))
1193
1194    def test_router_get_effective(self):
1195        '''
1196        Test get_effective_router
1197        '''
1198        router_get_effective = dict(
1199            BASE=dict(
1200                default_application='a1',
1201                applications=['a1', 'a2'],
1202            ),
1203            a1=dict(
1204                controllers=['c1a', 'c1b', 'default'],
1205            ),
1206            a2=dict(
1207                default_controller='c2',
1208                controllers=[],
1209            ),
1210            a3=dict(
1211                default_controller='c2',
1212                controllers=['c1'],
1213            ),
1214            a4=dict(
1215                default_function='f1',
1216                functions=['f2'],
1217            ),
1218        )
1219        load(rdict=router_get_effective)
1220        self.assertEqual(
1221            get_effective_router('BASE').applications, set(['a1', 'a2']))
1222        self.assertEqual(
1223            get_effective_router('BASE').default_application, 'a1')
1224        self.assertEqual(get_effective_router('BASE').domains, {})
1225        self.assertEqual(get_effective_router('a1').applications, None)
1226        self.assertEqual(get_effective_router('a1').default_application, None)
1227        self.assertEqual(get_effective_router('a1').domains, None)
1228        self.assertEqual(
1229            get_effective_router('a1').default_controller, "default")
1230        self.assertEqual(get_effective_router('a2').default_application, None)
1231        self.assertEqual(get_effective_router('a2').default_controller, "c2")
1232        self.assertEqual(get_effective_router(
1233            'a1').controllers, set(['c1a', 'c1b', 'default', 'static']))
1234        self.assertEqual(get_effective_router('a2').controllers, set())
1235        self.assertEqual(get_effective_router(
1236            'a3').controllers, set(['c1', 'c2', 'static']))
1237        self.assertEqual(get_effective_router(
1238            'a4').functions, dict(default=set(['f1', 'f2'])))
1239        self.assertEqual(get_effective_router('xx'), None)
1240
1241    def test_router_error(self):
1242        '''
1243        Test rewrite of HTTP errors
1244        '''
1245        router_err = dict()
1246        load(rdict=router_err)
1247        self.assertEqual(filter_err(200), 200)
1248        self.assertEqual(filter_err(399), 399)
1249        self.assertEqual(filter_err(400), 400)
1250
1251    def test_router_static_path(self):
1252        '''
1253        Test validation of static paths
1254        Stock pattern: file_match = r'([-+=@$%\w]+[./]?)+$'
1255
1256        '''
1257        load(rdict=dict())
1258        self.assertEqual(filter_url('http://domain.com/welcome/static/path/to/static').replace('/', os.sep),
1259            norm_root("%s/applications/welcome/static/path/to/static" % root))
1260        self.assertRaises(HTTP, filter_url, 'http://domain.com/welcome/static/bad/path/to/st~tic')
1261        self.assertEqual(filter_url('http://domain.com/welcome/static/path/to--/static').replace('/', os.sep),
1262            norm_root("%s/applications/welcome/static/path/to--/static" % root))
1263        self.assertEqual(filter_url('http://domain.com/welcome/static/path/==to--/static').replace('/', os.sep),
1264            norm_root("%s/applications/welcome/static/path/==to--/static" % root))
1265        self.assertEqual(filter_url('http://domain.com/welcome/static/path/-+=@$%/static').replace('/', os.sep),
1266            norm_root("%s/applications/welcome/static/path/-+=@$%%/static" % root))
1267        self.assertRaises(HTTP, filter_url, 'http://domain.com/welcome/static/bad/path/to/.static')
1268        self.assertRaises(HTTP, filter_url, 'http://domain.com/welcome/static/bad/path/to/s..tatic')
1269        self.assertRaises(HTTP, filter_url, 'http://domain.com/welcome/static/bad/path/to//static')
1270        self.assertRaises(HTTP, filter_url, 'http://domain.com/welcome/static/bad/path/to/#static')
1271
1272        router_static = dict(
1273            BASE=dict(
1274                file_match=r'([-+=@$%#\w]+[./]?)+$',   # legal static path
1275            ),
1276        )
1277        load(rdict=router_static)
1278        self.assertEqual(filter_url('http://domain.com/welcome/static/path/to/#static').replace('/', os.sep),
1279            norm_root("%s/applications/welcome/static/path/to/#static" % root))
1280
1281        router_static = dict(
1282            BASE=dict(
1283                file_match=r'[-+=@$%#.\w]+$',   # legal static path element
1284            ),
1285        )
1286        load(rdict=router_static)
1287        self.assertEqual(filter_url('http://domain.com/welcome/static/path/to/static').replace('/', os.sep),
1288            norm_root("%s/applications/welcome/static/path/to/static" % root))
1289        self.assertRaises(HTTP, filter_url, 'http://domain.com/welcome/static/bad/path/to/st~tic')
1290        self.assertEqual(filter_url('http://domain.com/welcome/static/path/to--/static').replace('/', os.sep),
1291            norm_root("%s/applications/welcome/static/path/to--/static" % root))
1292        self.assertEqual(filter_url('http://domain.com/welcome/static/path/==to--/static').replace('/', os.sep),
1293            norm_root("%s/applications/welcome/static/path/==to--/static" % root))
1294        self.assertEqual(filter_url('http://domain.com/welcome/static/path/-+=@$%/static').replace('/', os.sep),
1295            norm_root("%s/applications/welcome/static/path/-+=@$%%/static" % root))
1296        self.assertRaises(HTTP, filter_url, 'http://domain.com/welcome/static/bad/path/to//static')
1297        self.assertEqual(filter_url('http://domain.com/welcome/static/path/to/#static').replace('/', os.sep),
1298            norm_root("%s/applications/welcome/static/path/to/#static" % root))
1299        self.assertRaises(HTTP, filter_url, 'http://domain.com/welcome/static/bad/path/./static')
1300        self.assertRaises(HTTP, filter_url, 'http://domain.com/welcome/static/bad/path/../static')
1301        self.assertEqual(filter_url('http://domain.com/welcome/static/path/.../static').replace('/', os.sep),
1302            norm_root("%s/applications/welcome/static/path/.../static" % root))
1303        self.assertEqual(filter_url('http://domain.com/welcome/static/path/to/.static').replace('/', os.sep),
1304            norm_root("%s/applications/welcome/static/path/to/.static" % root))
1305
1306    def test_router_args(self):
1307        '''
1308        Test URL args parsing/generation
1309        '''
1310        load(rdict=dict())
1311        self.assertEqual(filter_url('http://domain.com/init/default/f/arg1'),
1312                         "/init/default/f ['arg1']")
1313        self.assertEqual(filter_url('http://domain.com/init/default/f/arg1/'),
1314                         "/init/default/f ['arg1']")
1315        self.assertEqual(filter_url('http://domain.com/init/default/f/arg1//'),
1316                         "/init/default/f ['arg1', '']")
1317        self.assertEqual(filter_url('http://domain.com/init/default/f//arg1'),
1318                         "/init/default/f ['', 'arg1']")
1319        self.assertEqual(
1320            filter_url('http://domain.com/init/default/f/arg1/arg2'),
1321            "/init/default/f ['arg1', 'arg2']")
1322        self.assertEqual(
1323            filter_url('http://domain.com/init/default/f/arg1//arg2'),
1324            "/init/default/f ['arg1', '', 'arg2']")
1325        self.assertEqual(
1326            filter_url('http://domain.com/init/default/f/arg1//arg3/'),
1327            "/init/default/f ['arg1', '', 'arg3']")
1328        self.assertEqual(
1329            filter_url('http://domain.com/init/default/f/arg1//arg3//'),
1330            "/init/default/f ['arg1', '', 'arg3', '']")
1331
1332        self.assertEqual(
1333            filter_url('http://domain.com/init/default/f', out=True), "/f")
1334        self.assertEqual(map_url_out(None, None, 'init', 'default',
1335                         'f', None, None, None, None, None), "/f")
1336        self.assertEqual(map_url_out(None, None, 'init', 'default',
1337                         'f', [], None, None, None, None), "/f")
1338        self.assertEqual(map_url_out(None, None, 'init', 'default',
1339                         'f', ['arg1'], None, None, None, None), "/f")
1340        self.assertEqual(map_url_out(None, None, 'init', 'default',
1341                         'f', ['arg1', ''], None, None, None, None), "/f")
1342        self.assertEqual(
1343            str(URL(a='init', c='default', f='f', args=None)), "/f")
1344        self.assertEqual(
1345            str(URL(a='init', c='default', f='f', args=['arg1'])), "/f/arg1")
1346        self.assertEqual(str(URL(
1347            a='init', c='default', f='f', args=['arg1', ''])), "/f/arg1//")
1348        self.assertEqual(str(URL(a='init', c='default', f='f',
1349                         args=['arg1', '', 'arg3'])), "/f/arg1//arg3")
1350        self.assertEqual(str(
1351            URL(a='init', c='default', f='f', args=['ar g'])), "/f/ar%20g")
1352        self.assertEqual(str(
1353            URL(a='init', c='default', f='f', args=['årg'])), "/f/%C3%A5rg")
1354        self.assertEqual(URL(a='init', c='default', f='fünc'), "/fünc")
1355        self.assertEqual(
1356            to_bytes(URL(a='init', c='default', f='fünc')), b"/f\xc3\xbcnc")
1357
1358    def test_routes_anchor(self):
1359        '''
1360        Test URL with anchor
1361        '''
1362        self.assertEqual(
1363            str(URL(a='a', c='c', f='f', anchor='anchor')), "/a/c/f#anchor")
1364        load(rdict=dict())
1365        self.assertEqual(
1366            str(URL(a='a', c='c', f='f', anchor='anchor')), "/a/c/f#anchor")
1367        args = ['a1', 'a2']
1368        self.assertEqual(
1369            str(URL(a='a', c='c', f='f', args=args, anchor='anchor')),
1370            "/a/c/f/a1/a2#anchor")
1371        vars = dict(v1=1, v2=2)
1372        self.assertEqual(
1373            str(URL(a='a', c='c', f='f', vars=vars, anchor='anchor')),
1374            "/a/c/f?v1=1&v2=2#anchor")
1375        self.assertEqual(
1376            str(URL(
1377                a='a', c='c', f='f', args=args, vars=vars, anchor='anchor')),
1378            "/a/c/f/a1/a2?v1=1&v2=2#anchor")
1379        self.assertEqual(str(URL(a='init', c='default', f='index')),
1380                         "/")
1381        self.assertEqual(str(URL(a='init', c='default', f='f')),
1382                         "/f")
1383        self.assertEqual(
1384            str(URL(a='init', c='default', f='index', anchor='anchor')),
1385            "/#anchor")
1386        self.assertEqual(
1387            str(URL(a='init', c='default', f='f', anchor='anchor')),
1388            "/f#anchor")
1389
1390    def test_router_prefix(self):
1391        '''
1392        Test path_prefix
1393        '''
1394        router_path_prefix = dict(
1395            BASE=dict(
1396                default_application='a1',
1397                applications=['a1', 'a2'],
1398                path_prefix='/path/to/apps',
1399            ),
1400            a1=dict(
1401                controllers=['c1a', 'c1b', 'default'],
1402            ),
1403            a2=dict(
1404                default_controller='c2',
1405                controllers=[],
1406            ),
1407        )
1408        load(rdict=router_path_prefix)
1409        self.assertEqual(str(URL(a='a1', c='c1a', f='f')),
1410                         "/path/to/apps/c1a/f")
1411        self.assertEqual(str(URL(a='a2', c='c', f='f')),
1412                         "/path/to/apps/a2/c/f")
1413        self.assertEqual(str(URL(a='a2', c='c2', f='f')),
1414                         "/path/to/apps/a2/c2/f")
1415        self.assertEqual(
1416            filter_url('http://domain.com/a1/'), "/a1/default/index")
1417        self.assertEqual(filter_url(
1418            'http://domain.com/path/to/apps/a1/'), "/a1/default/index")
1419        self.assertEqual(filter_url(
1420            'http://domain.com/path/to/a1/'), "/a1/default/path ['to', 'a1']")
1421
1422    def test_router_absolute(self):
1423        '''
1424        Test absolute URL
1425        '''
1426        load(rdict=dict())
1427        r = Storage()
1428        r.env = Storage()
1429        r.env.http_host = 'domain.com'
1430        r.env.wsgi_url_scheme = 'httpx'  # distinguish incoming scheme
1431        self.assertEqual(str(URL(r=r, a='a', c='c', f='f')), "/a/c/f")
1432        self.assertEqual(str(URL(r=r, a='a', c='c', f='f', host=True)),
1433                         "httpx://domain.com/a/c/f")
1434        self.assertEqual(str(URL(r=r, a='a', c='c', f='f', host='host.com')),
1435                         "httpx://host.com/a/c/f")
1436        self.assertEqual(str(URL(r=r, a='a', c='c', f='f', scheme=True)),
1437                         "httpx://domain.com/a/c/f")
1438        self.assertEqual(str(URL(r=r, a='a', c='c', f='f', scheme=False)),
1439                         "/a/c/f")
1440        self.assertEqual(str(URL(r=r, a='a', c='c', f='f', scheme='https')),
1441                         "https://domain.com/a/c/f")
1442        self.assertEqual(str(URL(r=r, a='a', c='c', f='f', scheme='wss')),
1443                         "wss://domain.com/a/c/f")
1444        self.assertEqual(
1445            str(URL(r=r, a='a', c='c', f='f', scheme=True, host=True)),
1446            "httpx://domain.com/a/c/f")
1447        self.assertEqual(
1448            str(URL(r=r, a='a', c='c', f='f', scheme='https', host=True)),
1449            "https://domain.com/a/c/f")
1450        self.assertEqual(
1451            str(URL(r=r, a='a', c='c', f='f', scheme=False, host=True)),
1452            "httpx://domain.com/a/c/f")
1453        self.assertEqual(
1454            str(URL(r=r, a='a', c='c', f='f', scheme=True, host='host.com')),
1455            "httpx://host.com/a/c/f")
1456        self.assertEqual(
1457            str(URL(r=r, a='a', c='c', f='f', scheme=False, host='host.com')),
1458            "httpx://host.com/a/c/f")
1459        self.assertEqual(str(URL(r=r, a='a', c='c', f='f', port=1234)),
1460                         "httpx://domain.com:1234/a/c/f")
1461        self.assertEqual(
1462            str(URL(r=r, a='a', c='c', f='f', scheme=True, port=1234)),
1463            "httpx://domain.com:1234/a/c/f")
1464        self.assertEqual(
1465            str(URL(r=r, a='a', c='c', f='f', host='host.com', port=1234)),
1466            "httpx://host.com:1234/a/c/f")
1467        self.assertEqual(
1468            str(URL(r=r, a='a', c='c', f='f', scheme='wss',
1469                host='host.com', port=1234)),
1470            "wss://host.com:1234/a/c/f")
1471
1472    def test_request_uri(self):
1473        '''
1474        Test REQUEST_URI in env
1475        '''
1476        load(rdict=dict())
1477
1478        self.assertEqual(
1479            filter_url('http://domain.com/abc', env=True).request_uri,
1480            '/init/default/abc')
1481        self.assertEqual(
1482            filter_url('http://domain.com/abc?def', env=True).request_uri,
1483            '/init/default/abc?def')
1484        self.assertEqual(
1485            filter_url('http://domain.com/index/abc', env=True).request_uri,
1486            "/init/default/index/abc")
1487        self.assertEqual(
1488            filter_url('http://domain.com/abc/def', env=True).request_uri,
1489            "/init/default/abc/def")
1490        self.assertEqual(
1491            filter_url('http://domain.com/index/a%20bc', env=True).request_uri,
1492            "/init/default/index/a%20bc")
1493
1494    def test_request_collide(self):
1495        '''
1496        Test controller-app name collision: admin vs welcome/admin
1497        '''
1498        router_collide = dict(
1499            BASE=dict(
1500                domains={
1501                    'ex.domain.com': 'examples',
1502                    'ad.domain.com': 'admin',
1503                    'welcome.com': 'welcome',
1504                    'www.welcome.com': 'welcome',
1505                },
1506                exclusive_domain=True,
1507            ),
1508        )
1509        load(rdict=router_collide)
1510
1511        # basic inbound
1512        self.assertEqual(
1513            filter_url('http://ex.domain.com'), '/examples/default/exdef')
1514        self.assertEqual(
1515            filter_url('http://ad.domain.com'), '/admin/default/index')
1516        self.assertEqual(
1517            filter_url('http://welcome.com'), '/welcome/default/index')
1518        self.assertEqual(
1519            filter_url('http://www.welcome.com'), '/welcome/default/index')
1520        # basic outbound
1521        self.assertEqual(filter_url('http://ex.domain.com/examples/default/exdef', domain='examples', out=True), "/")
1522        self.assertEqual(filter_url('http://ad.domain.com/admin/default/index',
1523                         domain='admin', out=True), "/")
1524        self.assertEqual(filter_url('http://welcome.com/welcome/default/index',
1525                         domain='welcome', out=True), "/")
1526        self.assertEqual(filter_url('http://www.welcome.com/welcome/default/index', domain='welcome', out=True), "/")
1527
1528        # inbound
1529        self.assertEqual(
1530            filter_url('http://welcome.com/admin'), '/welcome/admin/index')
1531        self.assertEqual(
1532            filter_url('http://welcome.com/f1'), '/welcome/default/f1')
1533        self.assertEqual(
1534            filter_url('http://ad.domain.com/shell'), '/admin/shell/index')
1535        self.assertEqual(
1536            filter_url('http://ad.domain.com/f1'), '/admin/default/f1')
1537        # outbound
1538        self.assertEqual(filter_url('http://welcome.com/welcome/other/index',
1539                         domain='welcome', out=True), "/other")
1540        self.assertEqual(filter_url('http://welcome.com/welcome/admin/index',
1541                         domain='welcome', out=True), "/admin")
1542        self.assertEqual(filter_url('http://ad.domain.com/admin/shell/index',
1543                         domain='admin', out=True), "/shell")
1544        self.assertEqual(filter_url('http://ad.domain.com/admin/default/f1',
1545                         domain='admin', out=True), "/f1")
1546        router_collide['BASE']['exclusive_domain'] = False
1547        load(rdict=router_collide)
1548        self.assertEqual(filter_url('http://welcome.com/welcome/admin/index',
1549                         domain='welcome', out=True), "/welcome/admin")
Note: See TracBrowser for help on using the repository browser.