web/test/unittest_urlrewrite.py
changeset 0 b97547f5f1fa
child 1398 5fe84a5f7035
equal deleted inserted replaced
-1:000000000000 0:b97547f5f1fa
       
     1 from logilab.common.testlib import TestCase, unittest_main
       
     2 
       
     3 from cubicweb.devtools._apptest import FakeRequest
       
     4 from cubicweb.devtools.apptest import EnvBasedTC
       
     5 
       
     6 from cubicweb.web.views.urlrewrite import SimpleReqRewriter, SchemaBasedRewriter, rgx, rgx_action
       
     7 
       
     8 
       
     9 class UrlRewriteTC(TestCase):
       
    10 
       
    11     def test_auto_extend_rules(self):
       
    12         class Rewriter(SimpleReqRewriter):
       
    13             rules = [
       
    14                 ('foo', dict(rql='Foo F')),
       
    15                 ('/index', dict(vid='index2')),
       
    16                 ]
       
    17         rules = []
       
    18         for pattern, values in Rewriter.rules:
       
    19             if hasattr(pattern, 'pattern'):
       
    20                 pattern = pattern.pattern
       
    21             rules.append((pattern, values))
       
    22         self.assertListEquals(rules, [
       
    23             ('foo' , dict(rql='Foo F')),
       
    24             ('/index' , dict(vid='index2')),
       
    25             ('/schema', {'vid': 'schema'}),
       
    26             ('/myprefs', dict(vid='epropertiesform')),
       
    27             ('/siteconfig', dict(vid='systemepropertiesform')),
       
    28             ('/manage', dict(vid='manage')),
       
    29             ('/notfound', {'vid': '404'}),
       
    30             ('/error', {'vid': 'error'}),
       
    31             ('/schema/([^/]+?)/?$', {'rql': r'Any X WHERE X is EEType, X name "\1"', 'vid': 'eschema'}),
       
    32             ('/add/([^/]+?)/?$' , dict(vid='creation', etype=r'\1')),
       
    33             ('/doc/images/(.+?)/?$', dict(fid='\\1', vid='wdocimages')),
       
    34             ('/doc/?$', dict(fid='main', vid='wdoc')),
       
    35             ('/doc/(.+?)/?$', dict(fid='\\1', vid='wdoc')),
       
    36             ('/changelog/?$', dict(vid='changelog')),
       
    37             # now in SchemaBasedRewriter
       
    38             #('/search/(.+)$', dict(rql=r'Any X WHERE X has_text "\1"')), 
       
    39             ])
       
    40 
       
    41 
       
    42     def test_no_extend_rules(self):
       
    43         class Rewriter(SimpleReqRewriter):
       
    44             ignore_baseclass_rules = True
       
    45             rules = [
       
    46                 ('foo', dict(rql='Foo F')),
       
    47                 ('/index', dict(vid='index2')),
       
    48                 ]
       
    49         self.assertListEquals(Rewriter.rules, [
       
    50             ('foo' , dict(rql='Foo F')),
       
    51             ('/index' , dict(vid='index2')),
       
    52             ])
       
    53 
       
    54     def test_basic_transformation(self):
       
    55         """test simple string-based rewrite"""
       
    56         rewriter = SimpleReqRewriter()
       
    57         req = FakeRequest()
       
    58         self.assertRaises(KeyError, rewriter.rewrite, req, '/view?vid=whatever')
       
    59         self.assertEquals(req.form, {})
       
    60         rewriter.rewrite(req, '/index')
       
    61         self.assertEquals(req.form, {'vid' : "index"})
       
    62 
       
    63     def test_regexp_transformation(self):
       
    64         """test regexp-based rewrite"""
       
    65         rewriter = SimpleReqRewriter()
       
    66         req = FakeRequest()
       
    67         rewriter.rewrite(req, '/add/Task')
       
    68         self.assertEquals(req.form, {'vid' : "creation", 'etype' : "Task"})
       
    69         req = FakeRequest()
       
    70         rewriter.rewrite(req, '/add/Task/')
       
    71         self.assertEquals(req.form, {'vid' : "creation", 'etype' : "Task"})
       
    72 
       
    73 
       
    74 
       
    75 
       
    76 class RgxActionRewriteTC(EnvBasedTC):
       
    77 
       
    78     def setup_database(self):
       
    79         self.p1 = self.create_user(u'user1')
       
    80         self.p1.set_attributes(firstname=u'joe', surname=u'Dalton')
       
    81         self.p2 = self.create_user(u'user2')
       
    82         self.p2.set_attributes(firstname=u'jack', surname=u'Dalton')
       
    83 
       
    84     def test_rgx_action_with_transforms(self):
       
    85         class TestSchemaBasedRewriter(SchemaBasedRewriter):
       
    86             rules = [
       
    87                 (rgx('/(?P<sn>\w+)/(?P<fn>\w+)'), rgx_action(r'Any X WHERE X surname %(sn)s, X firstname %(fn)s',
       
    88                                                                              argsgroups=('sn', 'fn'),
       
    89                                                                              transforms={'sn' : unicode.capitalize,
       
    90                                                                                          'fn' : unicode.lower,})),
       
    91                 ]
       
    92         rewriter = TestSchemaBasedRewriter()
       
    93         req = self.request()
       
    94         pmid, rset = rewriter.rewrite(req, u'/DaLToN/JoE')
       
    95         self.assertEquals(len(rset), 1)
       
    96         self.assertEquals(rset[0][0], self.p1.eid)
       
    97         
       
    98     
       
    99 
       
   100 if __name__ == '__main__':
       
   101     unittest_main()