1 from simplejson import loads

     2 

     3 from logilab.common.testlib import unittest_main

     4 from logilab.mtconverter import html_unescape

     5 

     6 from cubicweb.devtools.apptest import EnvBasedTC

     7 

     8 from cubicweb.web.htmlwidgets import TableWidget

     9 from cubicweb.web.views.baseviews import vid_from_rset

    10 

    11 def loadjson(value):

    12     return loads(html_unescape(value))

    13 

    14 class VidFromRsetTC(EnvBasedTC):

    15     

    16     def test_no_rset(self):

    17         req = self.request()

    18         self.assertEquals(vid_from_rset(req, None, self.schema), 'index')

    19     

    20     def test_no_entity(self):

    21         req = self.request()

    22         rset = self.execute('Any X WHERE X login "blabla"')

    23         self.assertEquals(vid_from_rset(req, rset, self.schema), 'noresult')

    24 

    25     def test_one_entity(self):

    26         req = self.request()

    27         rset = self.execute('Any X WHERE X login "admin"')

    28         self.assertEquals(vid_from_rset(req, rset, self.schema), 'primary')

    29         rset = self.execute('Any X, L WHERE X login "admin", X login L')

    30         self.assertEquals(vid_from_rset(req, rset, self.schema), 'primary')

    31         req.search_state = ('pasnormal',)

    32         rset = self.execute('Any X WHERE X login "admin"')

    33         self.assertEquals(vid_from_rset(req, rset, self.schema), 'outofcontext-search')

    34 

    35     def test_one_entity_eid(self):

    36         req = self.request()

    37         rset = self.execute('Any X WHERE X eid 1')

    38         self.assertEquals(vid_from_rset(req, rset, self.schema), 'primary')

    39         

    40     def test_more_than_one_entity(self):

    41         req = self.request()

    42         rset = self.execute('Any X WHERE X is EUser')

    43         self.assertEquals(vid_from_rset(req, rset, self.schema), 'list')

    44         rset = self.execute('Any X, L WHERE X login L')

    45         self.assertEquals(vid_from_rset(req, rset, self.schema), 'list')

    46     

    47     def test_more_than_one_entity_by_row(self):

    48         req = self.request()

    49         rset = self.execute('Any X, G WHERE X in_group G')

    50         self.assertEquals(vid_from_rset(req, rset, self.schema), 'table')

    51     

    52     def test_more_than_one_entity_by_row_2(self):

    53         req = self.request()

    54         rset = self.execute('Any X, GN WHERE X in_group G, G name GN')

    55         self.assertEquals(vid_from_rset(req, rset, self.schema), 'table')

    56     

    57     def test_aggregat(self):

    58         req = self.request()

    59         rset = self.execute('Any X, COUNT(T) GROUPBY X WHERE X is T')

    60         self.assertEquals(vid_from_rset(req, rset, self.schema), 'table')

    61         rset = self.execute('Any MAX(X) WHERE X is EUser')

    62         self.assertEquals(vid_from_rset(req, rset, self.schema), 'table')

    63 

    64     def test_subquery(self):

    65         rset = self.execute(

    66 'DISTINCT Any X,N ORDERBY N '

    67 'WITH X,N BEING ('

    68 '     (DISTINCT Any P,N WHERE P is EUser, P login N)'

    69 '       UNION'

    70 '     (DISTINCT Any W,N WHERE W is EGroup, W name N))')

    71         req = self.request()

    72         self.assertEquals(vid_from_rset(req, rset, self.schema), 'table')

    73 

    74 

    75 class TableViewTC(EnvBasedTC):

    76 

    77     def _prepare_entity(self):

    78         e = self.add_entity("State", name=u'<toto>', description=u'loo"ong blabla')

    79         rset = self.execute('Any X, D, CD, NOW - CD WHERE X is State, X description D, X creation_date CD, X eid %(x)s',

    80                             {'x': e.eid}, 'x')

    81         req = self.request()

    82         view = self.vreg.select_view('table', req, rset)

    83         return e, rset, view

    84       

    85     def test_headers(self):

    86         self.skip('implement me')

    87 

    88     def test_sortvalue(self):

    89         e, _, view = self._prepare_entity()

    90         expected = ['<toto>', 'loo"ong blabla'[:10], e.creation_date.strftime('%Y-%m-%d %H:%M')]

    91         got = [loadjson(view.sortvalue(0, i)) for i in xrange(3)]

    92         self.assertListEqual(got, expected)

    93         # XXX sqlite does not handle Interval correctly

    94         # value = loadjson(view.sortvalue(0, 3))

    95         # self.assertAlmostEquals(value, rset.rows[0][3].seconds)

    96 

    97     def test_sortvalue_with_display_col(self):

    98         e, rset, view = self._prepare_entity()

    99         rqlstdescr = rset.syntax_tree().get_description()[0] # XXX missing Union support

   100         table = TableWidget(view)

   101         table.columns = view.get_columns(rqlstdescr, [1, 2], None, None, None, None, 0)

   102         expected = ['loo"ong blabla'[:10], e.creation_date.strftime('%Y-%m-%d %H:%M')]

   103         got = [loadjson(value) for _, value in table.itercols(0)]

   104         self.assertListEqual(got, expected)

   105 

   106 

   107 if __name__ == '__main__':

   108     unittest_main()