Mercurial Mercurial > pub > hg > cubicweb / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
web/test/unittest_views_baseviews.py
changeset 9838 14640aeb5ddc
parent 9523 cd5738fc440f
child 10726 bb91f581c389
equal deleted inserted replaced
9837:64c8ee99baf7 9838:14640aeb5ddc 
     1 # copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 
     1 # copyright 2003-2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 
     2 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 
     2 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 
     3 #
 
     3 #
 
     4 # This file is part of CubicWeb.
 
     4 # This file is part of CubicWeb.
 
     5 #
 
     5 #
 
     6 # CubicWeb is free software: you can redistribute it and/or modify it under the
 
     6 # CubicWeb is free software: you can redistribute it and/or modify it under the
 
    20 from logilab.mtconverter import html_unescape
 
    20 from logilab.mtconverter import html_unescape
 
    21 
    21 
    22 from cubicweb.devtools.testlib import CubicWebTC
 
    22 from cubicweb.devtools.testlib import CubicWebTC
 
    23 from cubicweb.utils import json
 
    23 from cubicweb.utils import json
 
    24 from cubicweb.view import StartupView, TRANSITIONAL_DOCTYPE
 
    24 from cubicweb.view import StartupView, TRANSITIONAL_DOCTYPE
 
    25 from cubicweb.web.htmlwidgets import TableWidget
 
       
    26 from cubicweb.web.views import vid_from_rset
 
    25 from cubicweb.web.views import vid_from_rset
 
    27 
    26 
    28 def loadjson(value):
 
    27 def loadjson(value):
 
    29     return json.loads(html_unescape(value))
 
    28     return json.loads(html_unescape(value))
 
    30 
    29 
    31 class VidFromRsetTC(CubicWebTC):
 
    30 class VidFromRsetTC(CubicWebTC):
 
    32 
    31 
    33     def test_no_rset(self):
 
    32     def test_no_rset(self):
 
    34         req = self.request()
 
    33         with self.admin_access.web_request() as req:
 
    35         self.assertEqual(vid_from_rset(req, None, self.schema), 'index')
 
    34             self.assertEqual(vid_from_rset(req, None, self.schema), 'index')
 
    36 
    35 
    37     def test_no_entity(self):
 
    36     def test_no_entity(self):
 
    38         req = self.request()
 
    37         with self.admin_access.web_request() as req:
 
    39         rset = self.execute('Any X WHERE X login "blabla"')
 
    38             rset = req.execute('Any X WHERE X login "blabla"')
 
    40         self.assertEqual(vid_from_rset(req, rset, self.schema), 'noresult')
 
    39             self.assertEqual(vid_from_rset(req, rset, self.schema), 'noresult')
 
    41 
    40 
    42     def test_one_entity(self):
 
    41     def test_one_entity(self):
 
    43         req = self.request()
 
    42         with self.admin_access.web_request() as req:
 
    44         rset = self.execute('Any X WHERE X login "admin"')
 
    43             rset = req.execute('Any X WHERE X login "admin"')
 
    45         self.assertEqual(vid_from_rset(req, rset, self.schema), 'primary')
 
    44             self.assertEqual(vid_from_rset(req, rset, self.schema), 'primary')
 
    46         rset = self.execute('Any X, L WHERE X login "admin", X login L')
 
    45             rset = req.execute('Any X, L WHERE X login "admin", X login L')
 
    47         self.assertEqual(vid_from_rset(req, rset, self.schema), 'primary')
 
    46             self.assertEqual(vid_from_rset(req, rset, self.schema), 'primary')
 
    48         req.search_state = ('pasnormal',)
 
    47             req.search_state = ('pasnormal',)
 
    49         rset = self.execute('Any X WHERE X login "admin"')
 
    48             rset = req.execute('Any X WHERE X login "admin"')
 
    50         self.assertEqual(vid_from_rset(req, rset, self.schema), 'outofcontext-search')
 
    49             self.assertEqual(vid_from_rset(req, rset, self.schema), 'outofcontext-search')
 
    51 
    50 
    52     def test_one_entity_eid(self):
 
    51     def test_one_entity_eid(self):
 
    53         req = self.request()
 
    52         with self.admin_access.web_request() as req:
 
    54         rset = self.execute('Any X WHERE X eid 1')
 
    53             rset = req.execute('Any X WHERE X eid 1')
 
    55         self.assertEqual(vid_from_rset(req, rset, self.schema), 'primary')
 
    54             self.assertEqual(vid_from_rset(req, rset, self.schema), 'primary')
 
    56 
    55 
    57     def test_more_than_one_entity_same_type(self):
 
    56     def test_more_than_one_entity_same_type(self):
 
    58         req = self.request()
 
    57         with self.admin_access.web_request() as req:
 
    59         rset = self.execute('Any X WHERE X is CWUser')
 
    58             rset = req.execute('Any X WHERE X is CWUser')
 
    60         self.assertEqual(vid_from_rset(req, rset, self.schema), 'sameetypelist')
 
    59             self.assertEqual(vid_from_rset(req, rset, self.schema), 'sameetypelist')
 
    61         rset = self.execute('Any X, L WHERE X login L')
 
    60             rset = req.execute('Any X, L WHERE X login L')
 
    62         self.assertEqual(vid_from_rset(req, rset, self.schema), 'sameetypelist')
 
    61             self.assertEqual(vid_from_rset(req, rset, self.schema), 'sameetypelist')
 
    63 
    62 
    64     def test_more_than_one_entity_diff_type(self):
 
    63     def test_more_than_one_entity_diff_type(self):
 
    65         req = self.request()
 
    64         with self.admin_access.web_request() as req:
 
    66         rset = self.execute('Any X WHERE X is IN (CWUser, CWGroup)')
 
    65             rset = req.execute('Any X WHERE X is IN (CWUser, CWGroup)')
 
    67         self.assertEqual(vid_from_rset(req, rset, self.schema), 'list')
 
    66             self.assertEqual(vid_from_rset(req, rset, self.schema), 'list')
 
    68 
    67 
    69     def test_more_than_one_entity_by_row(self):
 
    68     def test_more_than_one_entity_by_row(self):
 
    70         req = self.request()
 
    69         with self.admin_access.web_request() as req:
 
    71         rset = self.execute('Any X, G WHERE X in_group G')
 
    70             rset = req.execute('Any X, G WHERE X in_group G')
 
    72         self.assertEqual(vid_from_rset(req, rset, self.schema), 'table')
 
    71             self.assertEqual(vid_from_rset(req, rset, self.schema), 'table')
 
    73 
    72 
    74     def test_more_than_one_entity_by_row_2(self):
 
    73     def test_more_than_one_entity_by_row_2(self):
 
    75         req = self.request()
 
    74         with self.admin_access.web_request() as req:
 
    76         rset = self.execute('Any X, GN WHERE X in_group G, G name GN')
 
    75             rset = req.execute('Any X, GN WHERE X in_group G, G name GN')
 
    77         self.assertEqual(vid_from_rset(req, rset, self.schema), 'table')
 
    76             self.assertEqual(vid_from_rset(req, rset, self.schema), 'table')
 
    78 
    77 
    79     def test_aggregat(self):
 
    78     def test_aggregat(self):
 
    80         req = self.request()
 
    79         with self.admin_access.web_request() as req:
 
    81         rset = self.execute('Any X, COUNT(T) GROUPBY X WHERE X is T')
 
    80             rset = req.execute('Any X, COUNT(T) GROUPBY X WHERE X is T')
 
    82         self.assertEqual(vid_from_rset(req, rset, self.schema), 'table')
 
    81             self.assertEqual(vid_from_rset(req, rset, self.schema), 'table')
 
    83         rset = self.execute('Any MAX(X) WHERE X is CWUser')
 
    82             rset = req.execute('Any MAX(X) WHERE X is CWUser')
 
    84         self.assertEqual(vid_from_rset(req, rset, self.schema), 'table')
 
    83             self.assertEqual(vid_from_rset(req, rset, self.schema), 'table')
 
    85 
    84 
    86     def test_subquery(self):
 
    85     def test_subquery(self):
 
    87         rset = self.execute(
 
    86         with self.admin_access.web_request() as req:
 
       
    87             rset = req.execute(
 
    88 'DISTINCT Any X,N ORDERBY N '
 
    88 'DISTINCT Any X,N ORDERBY N '
 
    89 'WITH X,N BEING ('
 
    89 'WITH X,N BEING ('
 
    90 '     (DISTINCT Any P,N WHERE P is CWUser, P login N)'
 
    90 '     (DISTINCT Any P,N WHERE P is CWUser, P login N)'
 
    91 '       UNION'
 
    91 '       UNION'
 
    92 '     (DISTINCT Any W,N WHERE W is CWGroup, W name N))')
 
    92 '     (DISTINCT Any W,N WHERE W is CWGroup, W name N))')
 
    93         req = self.request()
 
    93             self.assertEqual(vid_from_rset(req, rset, self.schema), 'table')
 
    94         self.assertEqual(vid_from_rset(req, rset, self.schema), 'table')
 
       
    95 
    94 
    96 
    95 
    97 class TableViewTC(CubicWebTC):
 
    96 class TableViewTC(CubicWebTC):
 
    98 
    97 
    99     def _prepare_entity(self):
 
    98     def _prepare_entity(self, req):
 
   100         req = self.request()
 
       
   101         e = req.create_entity("State", name=u'<toto>', description=u'loo"ong blabla')
 
    99         e = req.create_entity("State", name=u'<toto>', description=u'loo"ong blabla')
 
   102         rset = req.execute('Any X, D, CD, NOW - CD WHERE X is State, X description D, X creation_date CD, X eid %(x)s',
 
   100         rset = req.execute('Any X, D, CD, NOW - CD WHERE X is State, '
 
       
   101                            'X description D, X creation_date CD, X eid %(x)s',
 
   103                            {'x': e.eid})
 
   102                            {'x': e.eid})
 
   104         view = self.vreg['views'].select('table', req, rset=rset)
 
   103         view = self.vreg['views'].select('table', req, rset=rset)
 
   105         return e, rset, view
 
   104         return e, rset, view
 
   106 
   105 
   107     def test_headers(self):
 
       
   108         self.skipTest('implement me')
 
       
   109 
       
   110     def test_sortvalue(self):
 
   106     def test_sortvalue(self):
 
   111         e, _, view = self._prepare_entity()
 
   107         with self.admin_access.web_request() as req:
 
   112         colrenderers = view.build_column_renderers()[:3]
 
   108             e, _, view = self._prepare_entity(req)
 
   113         self.assertListEqual([renderer.sortvalue(0) for renderer in colrenderers],
 
   109             colrenderers = view.build_column_renderers()[:3]
 
   114                              [u'<toto>', u'loo"ong blabla', e.creation_date])
 
   110             self.assertListEqual([renderer.sortvalue(0) for renderer in colrenderers],
 
   115         # XXX sqlite does not handle Interval correctly
 
   111                                  [u'<toto>', u'loo"ong blabla', e.creation_date])
 
   116         # value = loadjson(view.sortvalue(0, 3))
 
       
   117         # self.assertAlmostEquals(value, rset.rows[0][3].seconds)
 
       
   118 
   112 
   119 
   113 
   120 class HTMLStreamTests(CubicWebTC):
 
   114 class HTMLStreamTests(CubicWebTC):
 
   121 
   115 
   122     def test_set_doctype_reset_xmldecl(self):
 
   116     def test_set_doctype_reset_xmldecl(self):
 
   127         class MyView(StartupView):
 
   121         class MyView(StartupView):
 
   128             __regid__ = 'my-view'
 
   122             __regid__ = 'my-view'
 
   129             def call(self):
 
   123             def call(self):
 
   130                 self._cw.set_doctype('<!DOCTYPE html>')
 
   124                 self._cw.set_doctype('<!DOCTYPE html>')
 
   131 
   125 
   132         with self.temporary_appobjects(MyView):
 
   126         with self.admin_access.web_request() as req:
 
   133             html_source = self.view('my-view').source
 
   127             with self.temporary_appobjects(MyView):
 
   134             source_lines = [line.strip() for line in html_source.splitlines(False)
 
   128                 html_source = self.view('my-view', req=req).source
 
   135                             if line.strip()]
 
   129                 source_lines = [line.strip()
 
   136             self.assertListEqual(['<!DOCTYPE html>', '<html xmlns:cubicweb="http://www.cubicweb.org" lang="en">'], source_lines[:2])
 
   130                                 for line in html_source.splitlines(False)
 
       
   131                                 if line.strip()]
 
       
   132                 self.assertListEqual(['<!DOCTYPE html>',
 
       
   133                                       '<html xmlns:cubicweb="http://www.cubicweb.org" lang="en">'],
 
       
   134                                      source_lines[:2])
 
   137 
   135 
   138     def test_set_doctype_no_reset_xmldecl(self):
 
   136     def test_set_doctype_no_reset_xmldecl(self):
 
   139         """
 
   137         """
 
   140         tests `cubicweb.web.request.CubicWebRequestBase.set_doctype`
 
   138         tests `cubicweb.web.request.CubicWebRequestBase.set_doctype`
 
   141         with no xmldecl reset
 
   139         with no xmldecl reset
 
   145             __regid__ = 'my-view'
 
   143             __regid__ = 'my-view'
 
   146             def call(self):
 
   144             def call(self):
 
   147                 self._cw.set_doctype(html_doctype)
 
   145                 self._cw.set_doctype(html_doctype)
 
   148                 self._cw.main_stream.set_htmlattrs([('lang', 'cz')])
 
   146                 self._cw.main_stream.set_htmlattrs([('lang', 'cz')])
 
   149 
   147 
   150         with self.temporary_appobjects(MyView):
 
   148         with self.admin_access.web_request() as req:
 
   151             html_source = self.view('my-view').source
 
   149             with self.temporary_appobjects(MyView):
 
   152             source_lines = [line.strip() for line in html_source.splitlines(False)
 
   150                 html_source = self.view('my-view', req=req).source
 
   153                             if line.strip()]
 
   151                 source_lines = [line.strip()
 
   154             self.assertListEqual([html_doctype, '<html xmlns:cubicweb="http://www.cubicweb.org" lang="cz">', '<head>'],
 
   152                                 for line in html_source.splitlines(False)
 
   155                                  source_lines[:3])
 
   153                                 if line.strip()]
 
       
   154                 self.assertListEqual([html_doctype,
 
       
   155                                       '<html xmlns:cubicweb="http://www.cubicweb.org" lang="cz">',
 
       
   156                                       '<head>'],
 
       
   157                                      source_lines[:3])
 
   156 
   158 
   157 if __name__ == '__main__':
 
   159 if __name__ == '__main__':
 
   158     unittest_main()
 
   160     unittest_main()
cubicweb