1 from logilab.common.date import datetime2ticks

     2 from cubicweb.devtools.testlib import CubicWebTC

     3 from cubicweb.web import facet

     4 

     5 class BaseFacetTC(CubicWebTC):

     6 

     7     def prepare_rqlst(self, req, rql='CWUser X', mainvar='X',

     8                       expected_baserql='Any X WHERE X is CWUser',

     9                       expected_preparedrql='DISTINCT Any  WHERE X is CWUser'):

    10         rset = req.cnx.execute(rql)

    11         rqlst = rset.syntax_tree().copy()

    12         filtered_variable, baserql = facet.init_facets(rset, rqlst.children[0],

    13                                                        mainvar=mainvar)

    14         self.assertEqual(filtered_variable.name, mainvar)

    15         self.assertEqual(baserql, expected_baserql)

    16         self.assertEqual(rqlst.as_string(), expected_preparedrql)

    17         return rset, rqlst, filtered_variable

    18 

    19     def _in_group_facet(self, req, cls=facet.RelationFacet, no_relation=False):

    20         rset, rqlst, filtered_variable = self.prepare_rqlst(req)

    21         cls.no_relation = no_relation

    22         f = cls(req, rset=rset, select=rqlst.children[0],

    23                 filtered_variable=filtered_variable)

    24         f.__regid__ = 'in_group'

    25         f.rtype = 'in_group'

    26         f.role = 'subject'

    27         f.target_attr = 'name'

    28         guests, managers = [eid for eid, in req.cnx.execute('CWGroup G ORDERBY GN '

    29                                                             'WHERE G name GN, G name IN ("guests", "managers")')]

    30         groups = [eid for eid, in req.cnx.execute('CWGroup G ORDERBY GN '

    31                                                   'WHERE G name GN, G name IN ("guests", "managers")')]

    32         return f, groups

    33 

    34     def test_relation_simple(self):

    35         with self.admin_access.web_request() as req:

    36             f, (guests, managers) = self._in_group_facet(req)

    37             self.assertEqual(f.vocabulary(),

    38                           [(u'guests', guests), (u'managers', managers)])

    39             # ensure rqlst is left unmodified

    40             self.assertEqual(f.select.as_string(), 'DISTINCT Any  WHERE X is CWUser')

    41             #rqlst = rset.syntax_tree()

    42             self.assertEqual(f.possible_values(),

    43                               [str(guests), str(managers)])

    44             # ensure rqlst is left unmodified

    45             self.assertEqual(f.select.as_string(), 'DISTINCT Any  WHERE X is CWUser')

    46             f._cw.form[f.__regid__] = str(guests)

    47             f.add_rql_restrictions()

    48             # selection is cluttered because rqlst has been prepared for facet (it

    49             # is not in real life)

    50             self.assertEqual(f.select.as_string(),

    51                              'DISTINCT Any  WHERE X is CWUser, X in_group D, D eid %s' % guests)

    52 

    53     def test_relation_multiple_and(self):

    54         with self.admin_access.web_request() as req:

    55             f, (guests, managers) = self._in_group_facet(req)

    56             f._cw.form[f.__regid__] = [str(guests), str(managers)]

    57             f._cw.form[f.__regid__ + '_andor'] = 'AND'

    58             f.add_rql_restrictions()

    59             self.assertEqual(f.select.as_string(),

    60                              'DISTINCT Any  WHERE X is CWUser, X in_group A, B eid %s, X in_group B, A eid %s' % (guests, managers))

    61 

    62     def test_relation_multiple_or(self):

    63         with self.admin_access.web_request() as req:

    64             f, (guests, managers) = self._in_group_facet(req)

    65             f._cw.form[f.__regid__] = [str(guests), str(managers)]

    66             f._cw.form[f.__regid__ + '_andor'] = 'OR'

    67             f.add_rql_restrictions()

    68             self.assertEqual(f.select.as_string(),

    69                              'DISTINCT Any  WHERE X is CWUser, X in_group A, A eid IN(%s, %s)' % (guests, managers))

    70 

    71     def test_relation_optional_rel(self):

    72         with self.admin_access.web_request() as req:

    73             rset = req.cnx.execute(u'Any X,GROUP_CONCAT(GN) GROUPBY X '

    74                                     'WHERE X in_group G?, G name GN, NOT G name "users"')

    75             rqlst = rset.syntax_tree().copy()

    76             select = rqlst.children[0]

    77             filtered_variable, baserql = facet.init_facets(rset, select)

    78 

    79             f = facet.RelationFacet(req, rset=rset,

    80                                     select=select,

    81                                     filtered_variable=filtered_variable)

    82             f.rtype = 'in_group'

    83             f.role = 'subject'

    84             f.target_attr = 'name'

    85             guests, managers = [eid for eid, in req.cnx.execute('CWGroup G ORDERBY GN '

    86                                                                 'WHERE G name GN, G name IN ("guests", "managers")')]

    87             self.assertEqual(f.vocabulary(),

    88                              [(u'guests', guests), (u'managers', managers)])

    89             # ensure rqlst is left unmodified

    90             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X in_group G?, G name GN, NOT G name "users"')

    91             #rqlst = rset.syntax_tree()

    92             self.assertEqual(sorted(f.possible_values()),

    93                              [str(guests), str(managers)])

    94             # ensure rqlst is left unmodified

    95             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X in_group G?, G name GN, NOT G name "users"')

    96             req.form[f.__regid__] = str(guests)

    97             f.add_rql_restrictions()

    98             # selection is cluttered because rqlst has been prepared for facet (it

    99             # is not in real life)

   100             self.assertEqual(f.select.as_string(),

   101                              'DISTINCT Any  WHERE X in_group G?, G name GN, NOT G name "users", X in_group D, D eid %s' % guests)

   102 

   103     def test_relation_no_relation_1(self):

   104         with self.admin_access.web_request() as req:

   105             f, (guests, managers) = self._in_group_facet(req, no_relation=True)

   106             self.assertEqual(f.vocabulary(),

   107                               [(u'guests', guests), (u'managers', managers)])

   108             self.assertEqual(f.possible_values(),

   109                               [str(guests), str(managers)])

   110             f._cw.create_entity('CWUser', login=u'hop', upassword='toto')

   111             self.assertEqual(f.vocabulary(),

   112                               [(u'<no relation>', ''), (u'guests', guests), (u'managers', managers)])

   113             self.assertEqual(f.possible_values(),

   114                               [str(guests), str(managers), ''])

   115             f._cw.form[f.__regid__] = ''

   116             f.add_rql_restrictions()

   117             self.assertEqual(f.select.as_string(),

   118                               'DISTINCT Any  WHERE X is CWUser, NOT X in_group G')

   119 

   120     def test_relation_no_relation_2(self):

   121         with self.admin_access.web_request() as req:

   122             f, (guests, managers) = self._in_group_facet(req, no_relation=True)

   123             f._cw.form[f.__regid__] = ['', guests]

   124             f.select.save_state()

   125             f.add_rql_restrictions()

   126             self.assertEqual(f.select.as_string(),

   127                               'DISTINCT Any  WHERE X is CWUser, (NOT X in_group B) OR (X in_group A, A eid %s)' % guests)

   128             f.select.recover()

   129             self.assertEqual(f.select.as_string(),

   130                               'DISTINCT Any  WHERE X is CWUser')

   131 

   132     def test_relationattribute(self):

   133         with self.admin_access.web_request() as req:

   134             f, (guests, managers) = self._in_group_facet(req, cls=facet.RelationAttributeFacet)

   135             self.assertEqual(f.vocabulary(),

   136                               [(u'guests', u'guests'), (u'managers', u'managers')])

   137             # ensure rqlst is left unmodified

   138             self.assertEqual(f.select.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   139             #rqlst = rset.syntax_tree()

   140             self.assertEqual(f.possible_values(),

   141                               ['guests', 'managers'])

   142             # ensure rqlst is left unmodified

   143             self.assertEqual(f.select.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   144             f._cw.form[f.__regid__] = u'guests'

   145             f.add_rql_restrictions()

   146             # selection is cluttered because rqlst has been prepared for facet (it

   147             # is not in real life)

   148             self.assertEqual(f.select.as_string(),

   149                              'DISTINCT Any  WHERE X is CWUser, X in_group E, E name "guests"')

   150 

   151     def test_hasrelation(self):

   152         with self.admin_access.web_request() as req:

   153             rset, rqlst, filtered_variable = self.prepare_rqlst(req)

   154             f = facet.HasRelationFacet(req, rset=rset,

   155                                        select=rqlst.children[0],

   156                                        filtered_variable=filtered_variable)

   157             f.__regid__ = 'has_group'

   158             f.rtype = 'in_group'

   159             f.role = 'subject'

   160             f._cw.form[f.__regid__] = 'feed me'

   161             f.add_rql_restrictions()

   162             self.assertEqual(f.select.as_string(),

   163                              'DISTINCT Any  WHERE X is CWUser, EXISTS(X in_group A)')

   164 

   165     def test_daterange(self):

   166         with self.admin_access.web_request() as req:

   167             rset, rqlst, filtered_variable = self.prepare_rqlst(req)

   168             f = facet.DateRangeFacet(req, rset=rset,

   169                                      select=rqlst.children[0],

   170                                      filtered_variable=filtered_variable)

   171             f.rtype = 'creation_date'

   172             mind, maxd = req.cnx.execute('Any MIN(CD), MAX(CD) WHERE X is CWUser, X creation_date CD')[0]

   173             self.assertEqual(f.vocabulary(),

   174                               [(str(mind), mind),

   175                                (str(maxd), maxd)])

   176             # ensure rqlst is left unmodified

   177             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   178             #rqlst = rset.syntax_tree()

   179             self.assertEqual(f.possible_values(),

   180                              [str(mind), str(maxd)])

   181             # ensure rqlst is left unmodified

   182             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   183             req.form['%s_inf' % f.__regid__] = str(datetime2ticks(mind))

   184             req.form['%s_sup' % f.__regid__] = str(datetime2ticks(mind))

   185             f.add_rql_restrictions()

   186             # selection is cluttered because rqlst has been prepared for facet (it

   187             # is not in real life)

   188             self.assertEqual(f.select.as_string(),

   189                               'DISTINCT Any  WHERE X is CWUser, X creation_date >= "%s", '

   190                              'X creation_date <= "%s"'

   191                              % (mind.strftime('%Y/%m/%d'),

   192                                 mind.strftime('%Y/%m/%d')))

   193 

   194     def test_attribute(self):

   195         with self.admin_access.web_request() as req:

   196             rset, rqlst, filtered_variable = self.prepare_rqlst(req)

   197             f = facet.AttributeFacet(req, rset=rset,

   198                                      select=rqlst.children[0],

   199                                      filtered_variable=filtered_variable)

   200             f.rtype = 'login'

   201             self.assertEqual(f.vocabulary(),

   202                               [(u'admin', u'admin'), (u'anon', u'anon')])

   203             # ensure rqlst is left unmodified

   204             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   205             #rqlst = rset.syntax_tree()

   206             self.assertEqual(f.possible_values(),

   207                               ['admin', 'anon'])

   208             # ensure rqlst is left unmodified

   209             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   210             req.form[f.__regid__] = u'admin'

   211             f.add_rql_restrictions()

   212             # selection is cluttered because rqlst has been prepared for facet (it

   213             # is not in real life)

   214             self.assertEqual(f.select.as_string(),

   215                              'DISTINCT Any  WHERE X is CWUser, X login "admin"')

   216 

   217     def test_bitfield(self):

   218         with self.admin_access.web_request() as req:

   219             rset, rqlst, filtered_variable = self.prepare_rqlst(req,

   220                 'CWAttribute X WHERE X ordernum XO',

   221                 expected_baserql='Any X WHERE X ordernum XO, X is CWAttribute',

   222                 expected_preparedrql='DISTINCT Any  WHERE X ordernum XO, X is CWAttribute')

   223             f = facet.BitFieldFacet(req, rset=rset,

   224                                     select=rqlst.children[0],

   225                                     filtered_variable=filtered_variable)

   226             f.choices = [('un', 1,), ('deux', 2,)]

   227             f.rtype = 'ordernum'

   228             self.assertEqual(f.vocabulary(),

   229                               [(u'deux', 2), (u'un', 1)])

   230             # ensure rqlst is left unmodified

   231             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X ordernum XO, X is CWAttribute')

   232             #rqlst = rset.syntax_tree()

   233             self.assertEqual(f.possible_values(),

   234                               ['2', '1'])

   235             # ensure rqlst is left unmodified

   236             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X ordernum XO, X is CWAttribute')

   237             req.form[f.__regid__] = '3'

   238             f.add_rql_restrictions()

   239             # selection is cluttered because rqlst has been prepared for facet (it

   240             # is not in real life)

   241             self.assertEqual(f.select.as_string(),

   242                               "DISTINCT Any  WHERE X ordernum XO, X is CWAttribute, X ordernum C HAVING 3 = (C & 3)")

   243 

   244     def test_bitfield_0_value(self):

   245         with self.admin_access.web_request() as req:

   246             rset, rqlst, filtered_variable = self.prepare_rqlst(req,

   247                 'CWAttribute X WHERE X ordernum XO',

   248                 expected_baserql='Any X WHERE X ordernum XO, X is CWAttribute',

   249                 expected_preparedrql='DISTINCT Any  WHERE X ordernum XO, X is CWAttribute')

   250             f = facet.BitFieldFacet(req, rset=rset,

   251                                     select=rqlst.children[0],

   252                                     filtered_variable=filtered_variable)

   253             f.choices = [('zero', 0,), ('un', 1,), ('deux', 2,)]

   254             f.rtype = 'ordernum'

   255             self.assertEqual(f.vocabulary(),

   256                               [(u'deux', 2), (u'un', 1), (u'zero', 0)])

   257             self.assertEqual(f.possible_values(),

   258                               ['2', '1', '0'])

   259             req.form[f.__regid__] = '0'

   260             f.add_rql_restrictions()

   261             self.assertEqual(f.select.as_string(),

   262                               "DISTINCT Any  WHERE X ordernum XO, X is CWAttribute, X ordernum C HAVING 0 = C")

   263 

   264     def test_rql_path_eid(self):

   265         with self.admin_access.web_request() as req:

   266             rset, rqlst, filtered_variable = self.prepare_rqlst(req)

   267             class RPF(facet.RQLPathFacet):

   268                 path = [('X created_by U'), ('U owned_by O'), ('O login OL')]

   269                 filter_variable = 'O'

   270                 label_variable = 'OL'

   271             f = RPF(req, rset=rset, select=rqlst.children[0],

   272                     filtered_variable=filtered_variable)

   273             self.assertEqual(f.vocabulary(), [(u'admin', req.user.eid),])

   274             # ensure rqlst is left unmodified

   275             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   276             #rqlst = rset.syntax_tree()

   277             self.assertEqual(f.possible_values(),

   278                              [str(req.user.eid),])

   279             # ensure rqlst is left unmodified

   280             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   281             req.form[f.__regid__] = '1'

   282             f.add_rql_restrictions()

   283             # selection is cluttered because rqlst has been prepared for facet (it

   284             # is not in real life)

   285             self.assertEqual(f.select.as_string(),

   286                              "DISTINCT Any  WHERE X is CWUser, X created_by F, F owned_by G, G eid 1")

   287 

   288     def test_rql_path_eid_no_label(self):

   289         with self.admin_access.web_request() as req:

   290             rset, rqlst, filtered_variable = self.prepare_rqlst(req)

   291             class RPF(facet.RQLPathFacet):

   292                 path = [('X created_by U'), ('U owned_by O'), ('O login OL')]

   293                 filter_variable = 'O'

   294             f = RPF(req, rset=rset, select=rqlst.children[0],

   295                     filtered_variable=filtered_variable)

   296             self.assertEqual(f.vocabulary(), [(str(req.user.eid), req.user.eid),])

   297 

   298     def test_rql_path_attr(self):

   299         with self.admin_access.web_request() as req:

   300             rset, rqlst, filtered_variable = self.prepare_rqlst(req)

   301             class RPF(facet.RQLPathFacet):

   302                 path = [('X created_by U'), ('U owned_by O'), ('O login OL')]

   303                 filter_variable = 'OL'

   304             f = RPF(req, rset=rset, select=rqlst.children[0],

   305                     filtered_variable=filtered_variable)

   306 

   307             self.assertEqual(f.vocabulary(), [(u'admin', 'admin'),])

   308             # ensure rqlst is left unmodified

   309             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   310             self.assertEqual(f.possible_values(), ['admin',])

   311             # ensure rqlst is left unmodified

   312             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   313             req.form[f.__regid__] = u'admin'

   314             f.add_rql_restrictions()

   315             # selection is cluttered because rqlst has been prepared for facet (it

   316             # is not in real life)

   317             self.assertEqual(f.select.as_string(),

   318                              'DISTINCT Any  WHERE X is CWUser, X created_by G, G owned_by H, H login "admin"')

   319 

   320     def test_rql_path_check_filter_label_variable(self):

   321         with self.admin_access.web_request() as req:

   322             rset, rqlst, filtered_variable = self.prepareg_aggregat_rqlst(req)

   323             class RPF(facet.RQLPathFacet):

   324                 path = [('X created_by U'), ('U owned_by O'), ('O login OL')]

   325                 filter_variable = 'OL'

   326                 label_variable = 'OL'

   327             self.assertRaises(AssertionError, RPF, req, rset=rset,

   328                               select=rqlst.children[0],

   329                               filtered_variable=filtered_variable)

   330 

   331 

   332     def test_rqlpath_range(self):

   333         with self.admin_access.web_request() as req:

   334             rset, rqlst, filtered_variable = self.prepare_rqlst(req)

   335             class RRF(facet.DateRangeRQLPathFacet):

   336                 path = [('X created_by U'), ('U owned_by O'), ('O creation_date OL')]

   337                 filter_variable = 'OL'

   338             f = RRF(req, rset=rset, select=rqlst.children[0],

   339                     filtered_variable=filtered_variable)

   340             mind, maxd = req.cnx.execute('Any MIN(CD), MAX(CD) WHERE X is CWUser, X created_by U, U owned_by O, O creation_date CD')[0]

   341             self.assertEqual(f.vocabulary(), [(str(mind), mind),

   342                                               (str(maxd), maxd)])

   343             # ensure rqlst is left unmodified

   344             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   345             self.assertEqual(f.possible_values(),

   346                              [str(mind), str(maxd)])

   347             # ensure rqlst is left unmodified

   348             self.assertEqual(rqlst.as_string(), 'DISTINCT Any  WHERE X is CWUser')

   349             req.form['%s_inf' % f.__regid__] = str(datetime2ticks(mind))

   350             req.form['%s_sup' % f.__regid__] = str(datetime2ticks(mind))

   351             f.add_rql_restrictions()

   352             # selection is cluttered because rqlst has been prepared for facet (it

   353             # is not in real life)

   354             self.assertEqual(f.select.as_string(),

   355                              'DISTINCT Any  WHERE X is CWUser, X created_by G, G owned_by H, H creation_date >= "%s", '

   356                              'H creation_date <= "%s"'

   357                              % (mind.strftime('%Y/%m/%d'),

   358                                 mind.strftime('%Y/%m/%d')))

   359 

   360     def prepareg_aggregat_rqlst(self, req):

   361         return self.prepare_rqlst(req,

   362             u'Any 1, COUNT(X) WHERE X is CWUser, X creation_date XD, '

   363              'X modification_date XM, Y creation_date YD, Y is CWGroup '

   364              'HAVING DAY(XD)>=DAY(YD) AND DAY(XM)<=DAY(YD)', 'X',

   365             expected_baserql=u'Any 1,COUNT(X) WHERE X is CWUser, X creation_date XD, '

   366             'X modification_date XM, Y creation_date YD, Y is CWGroup '

   367             'HAVING DAY(XD) >= DAY(YD), DAY(XM) <= DAY(YD)',

   368             expected_preparedrql=u'DISTINCT Any  WHERE X is CWUser, X creation_date XD, '

   369             'X modification_date XM, Y creation_date YD, Y is CWGroup '

   370             'HAVING DAY(XD) >= DAY(YD), DAY(XM) <= DAY(YD)')

   371 

   372 

   373     def test_aggregat_query_cleanup_select(self):

   374         with self.admin_access.web_request() as req:

   375             rset, rqlst, filtered_variable = self.prepareg_aggregat_rqlst(req)

   376             select = rqlst.children[0]

   377             facet.cleanup_select(select, filtered_variable=filtered_variable)

   378             self.assertEqual(select.as_string(),

   379                              'DISTINCT Any  WHERE X is CWUser, X creation_date XD, '

   380                              'X modification_date XM, Y creation_date YD, Y is CWGroup '

   381                              'HAVING DAY(XD) >= DAY(YD), DAY(XM) <= DAY(YD)')

   382 

   383     def test_aggregat_query_rql_path(self):

   384         with self.admin_access.web_request() as req:

   385             rset, rqlst, filtered_variable = self.prepareg_aggregat_rqlst(req)

   386             class RPF(facet.RQLPathFacet):

   387                 path = [('X created_by U'), ('U owned_by O'), ('O login OL')]

   388                 filter_variable = 'OL'

   389             f = RPF(req, rset=rset, select=rqlst.children[0],

   390                     filtered_variable=filtered_variable)

   391             self.assertEqual(f.vocabulary(), [(u'admin', u'admin')])

   392             self.assertEqual(f.possible_values(), ['admin'])

   393             req.form[f.__regid__] = u'admin'

   394             f.add_rql_restrictions()

   395             self.assertEqual(f.select.as_string(),

   396                              'DISTINCT Any  WHERE X is CWUser, X creation_date XD, '

   397                              'X modification_date XM, Y creation_date YD, Y is CWGroup, '

   398                              'X created_by G, G owned_by H, H login "admin" '

   399                              'HAVING DAY(XD) >= DAY(YD), DAY(XM) <= DAY(YD)')

   400 

   401     def test_aggregat_query_attribute(self):

   402         with self.admin_access.web_request() as req:

   403             rset, rqlst, filtered_variable = self.prepareg_aggregat_rqlst(req)

   404             f = facet.AttributeFacet(req, rset=rset,

   405                                      select=rqlst.children[0],

   406                                      filtered_variable=filtered_variable)

   407             f.rtype = 'login'

   408             self.assertEqual(f.vocabulary(),

   409                               [(u'admin', u'admin'), (u'anon', u'anon')])

   410             self.assertEqual(f.possible_values(),

   411                               ['admin', 'anon'])

   412             req.form[f.__regid__] = u'admin'

   413             f.add_rql_restrictions()

   414             self.assertEqual(f.select.as_string(),

   415                              'DISTINCT Any  WHERE X is CWUser, X creation_date XD, '

   416                              'X modification_date XM, Y creation_date YD, Y is CWGroup, X login "admin" '

   417                              'HAVING DAY(XD) >= DAY(YD), DAY(XM) <= DAY(YD)')

   418 

   419 if __name__ == '__main__':

   420     from logilab.common.testlib import unittest_main

   421     unittest_main()