test/unittest_selectors.py
branchstable
changeset 7677 134613d3b353
parent 7617 be5f68f9314e
child 7791 31bb51ea5485
child 7982 77ed9b2fc9a5
equal deleted inserted replaced
7670:6397a9051f65 7677:134613d3b353
    24 from cubicweb import Binary
    24 from cubicweb import Binary
    25 from cubicweb.devtools.testlib import CubicWebTC
    25 from cubicweb.devtools.testlib import CubicWebTC
    26 from cubicweb.appobject import Selector, AndSelector, OrSelector
    26 from cubicweb.appobject import Selector, AndSelector, OrSelector
    27 from cubicweb.selectors import (is_instance, adaptable, match_user_groups,
    27 from cubicweb.selectors import (is_instance, adaptable, match_user_groups,
    28                                 multi_lines_rset, score_entity, is_in_state,
    28                                 multi_lines_rset, score_entity, is_in_state,
    29                                 on_transition, rql_condition)
    29                                 on_transition, rql_condition, relation_possible)
    30 from cubicweb.web import action
    30 from cubicweb.web import action
    31 
    31 
    32 
    32 
    33 class _1_(Selector):
    33 class _1_(Selector):
    34     def __call__(self, *args, **kwargs):
    34     def __call__(self, *args, **kwargs):
   100         self.assertIs(sel.search_selector(is_instance), sel)
   100         self.assertIs(sel.search_selector(is_instance), sel)
   101         csel = AndSelector(sel, Selector())
   101         csel = AndSelector(sel, Selector())
   102         self.assertIs(csel.search_selector(is_instance), sel)
   102         self.assertIs(csel.search_selector(is_instance), sel)
   103         csel = AndSelector(Selector(), sel)
   103         csel = AndSelector(Selector(), sel)
   104         self.assertIs(csel.search_selector(is_instance), sel)
   104         self.assertIs(csel.search_selector(is_instance), sel)
       
   105         self.assertIs(csel.search_selector((AndSelector, OrSelector)), csel)
       
   106         self.assertIs(csel.search_selector((OrSelector, AndSelector)), csel)
       
   107         self.assertIs(csel.search_selector((is_instance, score_entity)),  sel)
       
   108         self.assertIs(csel.search_selector((score_entity, is_instance)), sel)
   105 
   109 
   106     def test_inplace_and(self):
   110     def test_inplace_and(self):
   107         selector = _1_()
   111         selector = _1_()
   108         selector &= _1_()
   112         selector &= _1_()
   109         selector &= _1_()
   113         selector &= _1_()
   138         selector |= _0_()
   142         selector |= _0_()
   139         selector |= _0_()
   143         selector |= _0_()
   140         self.assertEqual(selector(None), 0)
   144         self.assertEqual(selector(None), 0)
   141 
   145 
   142 
   146 
   143 class IsInStateSelectorTC(CubicWebTC):
       
   144     def setup_database(self):
       
   145         wf = self.shell().add_workflow("testwf", 'StateFull', default=True)
       
   146         initial = wf.add_state(u'initial', initial=True)
       
   147         final = wf.add_state(u'final')
       
   148         wf.add_transition(u'forward', (initial,), final)
       
   149 
       
   150     def test_initial_state(self):
       
   151         req = self.request()
       
   152         entity = req.create_entity('StateFull')
       
   153         selector = is_in_state(u'initial')
       
   154         self.commit()
       
   155         score = selector(entity.__class__, None, entity=entity)
       
   156         self.assertEqual(score, 1)
       
   157 
       
   158     def test_final_state(self):
       
   159         req = self.request()
       
   160         entity = req.create_entity('StateFull')
       
   161         selector = is_in_state(u'initial')
       
   162         self.commit()
       
   163         entity.cw_adapt_to('IWorkflowable').fire_transition(u'forward')
       
   164         self.commit()
       
   165         score = selector(entity.__class__, None, entity=entity)
       
   166         self.assertEqual(score, 0)
       
   167         selector = is_in_state(u'final')
       
   168         score = selector(entity.__class__, None, entity=entity)
       
   169         self.assertEqual(score, 1)
       
   170 
       
   171 
       
   172 class ImplementsSelectorTC(CubicWebTC):
   147 class ImplementsSelectorTC(CubicWebTC):
   173     def test_etype_priority(self):
   148     def test_etype_priority(self):
   174         req = self.request()
   149         req = self.request()
   175         f = req.create_entity('File', data_name=u'hop.txt', data=Binary('hop'))
   150         f = req.create_entity('File', data_name=u'hop.txt', data=Binary('hop'))
   176         rset = f.as_rset()
   151         rset = f.as_rset()
   191 
   166 
   192 
   167 
   193 class WorkflowSelectorTC(CubicWebTC):
   168 class WorkflowSelectorTC(CubicWebTC):
   194     def _commit(self):
   169     def _commit(self):
   195         self.commit()
   170         self.commit()
   196         self.wf_entity.clear_all_caches()
   171         self.wf_entity.cw_clear_all_caches()
   197 
   172 
   198     def setup_database(self):
   173     def setup_database(self):
   199         wf = self.shell().add_workflow("wf_test", 'StateFull', default=True)
   174         wf = self.shell().add_workflow("wf_test", 'StateFull', default=True)
   200         created   = wf.add_state('created', initial=True)
   175         created   = wf.add_state('created', initial=True)
   201         validated = wf.add_state('validated')
   176         validated = wf.add_state('validated')
   311         self.assertEqual(selector(None, self.req, rset=self.rset), 0)
   286         self.assertEqual(selector(None, self.req, rset=self.rset), 0)
   312         selector = on_transition("validate", "forsake")
   287         selector = on_transition("validate", "forsake")
   313         self.assertEqual(selector(None, self.req, rset=self.rset), 0)
   288         self.assertEqual(selector(None, self.req, rset=self.rset), 0)
   314         selector = on_transition("forsake")
   289         selector = on_transition("forsake")
   315         self.assertEqual(selector(None, self.req, rset=self.rset), 0)
   290         self.assertEqual(selector(None, self.req, rset=self.rset), 0)
       
   291 
       
   292 
       
   293 class RelationPossibleTC(CubicWebTC):
       
   294 
       
   295     def test_rqlst_1(self):
       
   296         req = self.request()
       
   297         selector = relation_possible('in_group')
       
   298         select = self.vreg.parse(req, 'Any X WHERE X is CWUser').children[0]
       
   299         score = selector(None, req, rset=1,
       
   300                          select=select, filtered_variable=select.defined_vars['X'])
       
   301         self.assertEqual(score, 1)
       
   302 
       
   303     def test_rqlst_2(self):
       
   304         req = self.request()
       
   305         selector = relation_possible('in_group')
       
   306         select = self.vreg.parse(req, 'Any 1, COUNT(X) WHERE X is CWUser, X creation_date XD, '
       
   307                                  'Y creation_date YD, Y is CWGroup '
       
   308                                  'HAVING DAY(XD)=DAY(YD)').children[0]
       
   309         score = selector(None, req, rset=1,
       
   310                          select=select, filtered_variable=select.defined_vars['X'])
       
   311         self.assertEqual(score, 1)
   316 
   312 
   317 
   313 
   318 class MatchUserGroupsTC(CubicWebTC):
   314 class MatchUserGroupsTC(CubicWebTC):
   319     def test_owners_group(self):
   315     def test_owners_group(self):
   320         """tests usage of 'owners' group with match_user_group"""
   316         """tests usage of 'owners' group with match_user_group"""