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.
entities/test/unittest_base.py
branchtls-sprint
changeset 1642 12a98b17fb05
parent 1398 5fe84a5f7035
child 1977 606923dff11b
equal deleted inserted replaced
1641:2c80b09d8d86 1642:12a98b17fb05 
    16 
    16 
    17 class BaseEntityTC(EnvBasedTC):
 
    17 class BaseEntityTC(EnvBasedTC):
 
    18 
    18 
    19     def setup_database(self):
 
    19     def setup_database(self):
 
    20         self.member = self.create_user('member')
 
    20         self.member = self.create_user('member')
 
    21     
    21 
    22                      
    22 
    23     
    23 
    24 class MetadataTC(BaseEntityTC):
 
    24 class MetadataTC(BaseEntityTC):
 
    25 
    25 
    26     def test_creator(self):
 
    26     def test_creator(self):
 
    27         self.login(u'member')
 
    27         self.login(u'member')
 
    28         card = self.add_entity('Card', title=u"hello")
 
    28         entity = self.add_entity('Bookmark', title=u"hello", path=u'project/cubicweb')
 
    29         self.commit()
 
    29         self.commit()
 
    30         self.assertEquals(card.creator.eid, self.member.eid)
 
    30         self.assertEquals(entity.creator.eid, self.member.eid)
 
    31         self.assertEquals(card.dc_creator(), u'member')
 
    31         self.assertEquals(entity.dc_creator(), u'member')
 
    32 
    32 
    33     def test_type(self):
 
    33     def test_type(self):
 
    34         self.assertEquals(self.member.dc_type(), 'euser')
 
    34         self.assertEquals(self.member.dc_type(), 'cwuser')
 
    35         
       
    36 
    35 
    37     def test_entity_meta_attributes(self):
 
    36     def test_entity_meta_attributes(self):
 
    38         # XXX move to yams
 
    37         # XXX move to yams
 
    39         self.assertEquals(self.schema['CWUser'].meta_attributes(), {})
 
    38         self.assertEquals(self.schema['CWUser'].meta_attributes(), {})
 
    40         self.assertEquals(dict((str(k), v) for k, v in self.schema['Card'].meta_attributes().iteritems()),
 
    39         self.assertEquals(dict((str(k), v) for k, v in self.schema['State'].meta_attributes().iteritems()),
 
    41                           {'content_format': ('format', 'content')})
 
    40                           {'description_format': ('format', 'description')})
 
    42         
    41 
    43 
    42 
    44 class CWUserTC(BaseEntityTC):
 
    43 class CWUserTC(BaseEntityTC):
 
    45     def test_dc_title_and_name(self):
 
    44     def test_dc_title_and_name(self):
 
    46         e = self.entity('CWUser U WHERE U login "member"')
 
    45         e = self.entity('CWUser U WHERE U login "member"')
 
    47         self.assertEquals(e.dc_title(), 'member')
 
    46         self.assertEquals(e.dc_title(), 'member')
 
    51         self.assertEquals(e.name(), u'bouah')
 
    50         self.assertEquals(e.name(), u'bouah')
 
    52         self.execute(u'SET X surname "lôt" WHERE X is CWUser, X login "member"')
 
    51         self.execute(u'SET X surname "lôt" WHERE X is CWUser, X login "member"')
 
    53         self.assertEquals(e.dc_title(), 'member')
 
    52         self.assertEquals(e.dc_title(), 'member')
 
    54         self.assertEquals(e.name(), u'bouah lôt')
 
    53         self.assertEquals(e.name(), u'bouah lôt')
 
    55 
    54 
    56     
    55 
    57 class StateAndTransitionsTC(BaseEntityTC):
 
    56 class StateAndTransitionsTC(BaseEntityTC):
 
    58         
    57 
    59     def test_transitions(self):
 
    58     def test_transitions(self):
 
    60         user = self.entity('CWUser X')
 
    59         user = self.entity('CWUser X')
 
    61         e = self.entity('State S WHERE S name "activated"')
 
    60         e = self.entity('State S WHERE S name "activated"')
 
    62         trs = list(e.transitions(user))
 
    61         trs = list(e.transitions(user))
 
    63         self.assertEquals(len(trs), 1)
 
    62         self.assertEquals(len(trs), 1)
 
    72         trs = list(e.transitions(user))
 
    71         trs = list(e.transitions(user))
 
    73         self.assertEquals(len(trs), 0)
 
    72         self.assertEquals(len(trs), 0)
 
    74         user = self.entity('CWUser X')
 
    73         user = self.entity('CWUser X')
 
    75         self.assert_(not user.can_pass_transition('deactivate'))
 
    74         self.assert_(not user.can_pass_transition('deactivate'))
 
    76         self.assert_(not user.can_pass_transition('activate'))
 
    75         self.assert_(not user.can_pass_transition('activate'))
 
    77         
    76 
    78     def test_transitions_with_dest_specfied(self):
 
    77     def test_transitions_with_dest_specfied(self):
 
    79         user = self.entity('CWUser X')
 
    78         user = self.entity('CWUser X')
 
    80         e = self.entity('State S WHERE S name "activated"')
 
    79         e = self.entity('State S WHERE S name "activated"')
 
    81         e2 = self.entity('State S WHERE S name "deactivated"')
 
    80         e2 = self.entity('State S WHERE S name "deactivated"')
 
    82         trs = list(e.transitions(user, e2.eid))
 
    81         trs = list(e.transitions(user, e2.eid))
 
    83         self.assertEquals(len(trs), 1)
 
    82         self.assertEquals(len(trs), 1)
 
    84         self.assertEquals(trs[0].name, u'deactivate')
 
    83         self.assertEquals(trs[0].name, u'deactivate')
 
    85         self.assertEquals(trs[0].destination().name, u'deactivated')
 
    84         self.assertEquals(trs[0].destination().name, u'deactivated')
 
    86         trs = list(e.transitions(user, e.eid))
 
    85         trs = list(e.transitions(user, e.eid))
 
    87         self.assertEquals(len(trs), 0)
 
    86         self.assertEquals(len(trs), 0)
 
    88     
    87 
    89     def test_transitions_maybe_passed(self):
 
    88     def test_transitions_maybe_passed(self):
 
    90         self.execute('INSERT RQLExpression X: X exprtype "ERQLExpression", '
 
    89         self.execute('INSERT RQLExpression X: X exprtype "ERQLExpression", '
 
    91                      'X expression "X owned_by U", T condition X '
 
    90                      'X expression "X owned_by U", T condition X '
 
    92                      'WHERE T name "deactivate"')
 
    91                      'WHERE T name "deactivate"')
 
    93         self._test_deactivated()
 
    92         self._test_deactivated()
 
    94         
    93 
    95     def test_transitions_maybe_passed_using_has_update_perm(self):
 
    94     def test_transitions_maybe_passed_using_has_update_perm(self):
 
    96         self.execute('INSERT RQLExpression X: X exprtype "ERQLExpression", '
 
    95         self.execute('INSERT RQLExpression X: X exprtype "ERQLExpression", '
 
    97                      'X expression "U has_update_permission X", T condition X '
 
    96                      'X expression "U has_update_permission X", T condition X '
 
    98                      'WHERE T name "deactivate"')
 
    97                      'WHERE T name "deactivate"')
 
    99         self._test_deactivated()
 
    98         self._test_deactivated()
 
   100         
    99 
   101         
   100 
   102     def _test_deactivated(self):
 
   101     def _test_deactivated(self):
 
   103         ueid = self.create_user('toto').eid
 
   102         ueid = self.create_user('toto').eid
 
   104         self.create_user('tutu')
 
   103         self.create_user('tutu')
 
   105         cnx = self.login('tutu')
 
   104         cnx = self.login('tutu')
 
   106         cu = cnx.cursor()
 
   105         cu = cnx.cursor()
 
   114                    {'x': ueid}, 'x')
 
   113                    {'x': ueid}, 'x')
 
   115         cnx.commit()
 
   114         cnx.commit()
 
   116         self.assertRaises(ValidationError,
 
   115         self.assertRaises(ValidationError,
 
   117                           cu.execute, 'SET X in_state S WHERE X eid %(x)s, S name "activated"',
 
   116                           cu.execute, 'SET X in_state S WHERE X eid %(x)s, S name "activated"',
 
   118                           {'x': ueid}, 'x')
 
   117                           {'x': ueid}, 'x')
 
   119     
   118 
   120 
   119 
   121     def test_transitions_selection(self):
 
   120     def test_transitions_selection(self):
 
   122         """
 
   121         """
 
   123         ------------------------  tr1    -----------------
 
   122         ------------------------  tr1    -----------------
 
   124         | state1 (Card, Bookmark) | ------> | state2 (Card) |
 
   123         | state1 (CWGroup, Bookmark) | ------> | state2 (CWGroup) |
 
   125         ------------------------         -----------------
 
   124         ------------------------         -----------------
 
   126                   |  tr2    ------------------
 
   125                   |  tr2    ------------------
 
   127                   `------>  | state3 (Bookmark) |
 
   126                   `------>  | state3 (Bookmark) |
 
   128                             ------------------
 
   127                             ------------------
 
   129         """
 
   128         """
 
   130         state1 = self.add_entity('State', name=u'state1')
 
   129         state1 = self.add_entity('State', name=u'state1')
 
   131         state2 = self.add_entity('State', name=u'state2')
 
   130         state2 = self.add_entity('State', name=u'state2')
 
   132         state3 = self.add_entity('State', name=u'state3')
 
   131         state3 = self.add_entity('State', name=u'state3')
 
   133         tr1 = self.add_entity('Transition', name=u'tr1')
 
   132         tr1 = self.add_entity('Transition', name=u'tr1')
 
   134         tr2 = self.add_entity('Transition', name=u'tr2')
 
   133         tr2 = self.add_entity('Transition', name=u'tr2')
 
   135         self.execute('SET X state_of Y WHERE X eid in (%s, %s), Y is CWEType, Y name "Card"' %
 
   134         self.execute('SET X state_of Y WHERE X eid in (%s, %s), Y is CWEType, Y name "CWGroup"' %
 
   136                       (state1.eid, state2.eid))
 
   135                       (state1.eid, state2.eid))
 
   137         self.execute('SET X state_of Y WHERE X eid in (%s, %s), Y is CWEType, Y name "Bookmark"' %
 
   136         self.execute('SET X state_of Y WHERE X eid in (%s, %s), Y is CWEType, Y name "Bookmark"' %
 
   138                       (state1.eid, state3.eid))
 
   137                       (state1.eid, state3.eid))
 
   139         self.execute('SET X transition_of Y WHERE X eid %s, Y name "Card"' % tr1.eid)
 
   138         self.execute('SET X transition_of Y WHERE X eid %s, Y name "CWGroup"' % tr1.eid)
 
   140         self.execute('SET X transition_of Y WHERE X eid %s, Y name "Bookmark"' % tr2.eid)
 
   139         self.execute('SET X transition_of Y WHERE X eid %s, Y name "Bookmark"' % tr2.eid)
 
   141         self.execute('SET X allowed_transition Y WHERE X eid %s, Y eid %s' %
 
   140         self.execute('SET X allowed_transition Y WHERE X eid %s, Y eid %s' %
 
   142                       (state1.eid, tr1.eid))
 
   141                       (state1.eid, tr1.eid))
 
   143         self.execute('SET X allowed_transition Y WHERE X eid %s, Y eid %s' %
 
   142         self.execute('SET X allowed_transition Y WHERE X eid %s, Y eid %s' %
 
   144                       (state1.eid, tr2.eid))
 
   143                       (state1.eid, tr2.eid))
 
   145         self.execute('SET X destination_state Y WHERE X eid %s, Y eid %s' %
 
   144         self.execute('SET X destination_state Y WHERE X eid %s, Y eid %s' %
 
   146                       (tr1.eid, state2.eid))
 
   145                       (tr1.eid, state2.eid))
 
   147         self.execute('SET X destination_state Y WHERE X eid %s, Y eid %s' %
 
   146         self.execute('SET X destination_state Y WHERE X eid %s, Y eid %s' %
 
   148                       (tr2.eid, state3.eid))
 
   147                       (tr2.eid, state3.eid))
 
   149         self.execute('SET X initial_state Y WHERE Y eid %s, X name "Card"' % state1.eid)
 
   148         self.execute('SET X initial_state Y WHERE Y eid %s, X name "CWGroup"' % state1.eid)
 
   150         self.execute('SET X initial_state Y WHERE Y eid %s, X name "Bookmark"' % state1.eid)
 
   149         self.execute('SET X initial_state Y WHERE Y eid %s, X name "Bookmark"' % state1.eid)
 
   151         card = self.add_entity('Card', title=u't1')
 
   150         group = self.add_entity('CWGroup', name=u't1')
 
       
   151         transitions = list(state1.transitions(group))
 
       
   152         self.assertEquals(len(transitions), 1)
 
       
   153         self.assertEquals(transitions[0].name, 'tr1')
 
   152         bookmark = self.add_entity('Bookmark', title=u'111', path=u'/view')
 
   154         bookmark = self.add_entity('Bookmark', title=u'111', path=u'/view')
 
   153         
       
   154         transitions = list(state1.transitions(card))
 
       
   155         self.assertEquals(len(transitions), 1)
 
       
   156         self.assertEquals(transitions[0].name, 'tr1')
 
       
   157         transitions = list(state1.transitions(bookmark))
 
   155         transitions = list(state1.transitions(bookmark))
 
   158         self.assertEquals(len(transitions), 1)
 
   156         self.assertEquals(len(transitions), 1)
 
   159         self.assertEquals(transitions[0].name, 'tr2')
 
   157         self.assertEquals(transitions[0].name, 'tr2')
 
   160         
   158 
   161 
   159 
   162     def test_transitions_selection2(self):
 
   160     def test_transitions_selection2(self):
 
   163         """
 
   161         """
 
   164         ------------------------  tr1 (Bookmark)   -----------------------
 
   162         ------------------------  tr1 (Bookmark)   -----------------------
 
   165         | state1 (Card, Bookmark) | -------------> | state2 (Card,Bookmark) |
 
   163         | state1 (CWGroup, Bookmark) | -------------> | state2 (CWGroup,Bookmark) |
 
   166         ------------------------                -----------------------
 
   164         ------------------------                -----------------------
 
   167                   |  tr2 (Card)                     |
 
   165                   |  tr2 (CWGroup)                     |
 
   168                   `---------------------------------/
 
   166                   `---------------------------------/
 
   169         """
 
   167         """
 
   170         state1 = self.add_entity('State', name=u'state1')
 
   168         state1 = self.add_entity('State', name=u'state1')
 
   171         state2 = self.add_entity('State', name=u'state2')
 
   169         state2 = self.add_entity('State', name=u'state2')
 
   172         tr1 = self.add_entity('Transition', name=u'tr1')
 
   170         tr1 = self.add_entity('Transition', name=u'tr1')
 
   173         tr2 = self.add_entity('Transition', name=u'tr2')
 
   171         tr2 = self.add_entity('Transition', name=u'tr2')
 
   174         self.execute('SET X state_of Y WHERE X eid in (%s, %s), Y is CWEType, Y name "Card"' %
 
   172         self.execute('SET X state_of Y WHERE X eid in (%s, %s), Y is CWEType, Y name "CWGroup"' %
 
   175                       (state1.eid, state2.eid))
 
   173                       (state1.eid, state2.eid))
 
   176         self.execute('SET X state_of Y WHERE X eid in (%s, %s), Y is CWEType, Y name "Bookmark"' %
 
   174         self.execute('SET X state_of Y WHERE X eid in (%s, %s), Y is CWEType, Y name "Bookmark"' %
 
   177                       (state1.eid, state2.eid))
 
   175                       (state1.eid, state2.eid))
 
   178         self.execute('SET X transition_of Y WHERE X eid %s, Y name "Card"' % tr1.eid)
 
   176         self.execute('SET X transition_of Y WHERE X eid %s, Y name "CWGroup"' % tr1.eid)
 
   179         self.execute('SET X transition_of Y WHERE X eid %s, Y name "Bookmark"' % tr2.eid)
 
   177         self.execute('SET X transition_of Y WHERE X eid %s, Y name "Bookmark"' % tr2.eid)
 
   180         self.execute('SET X allowed_transition Y WHERE X eid %s, Y eid %s' %
 
   178         self.execute('SET X allowed_transition Y WHERE X eid %s, Y eid %s' %
 
   181                       (state1.eid, tr1.eid))
 
   179                       (state1.eid, tr1.eid))
 
   182         self.execute('SET X allowed_transition Y WHERE X eid %s, Y eid %s' %
 
   180         self.execute('SET X allowed_transition Y WHERE X eid %s, Y eid %s' %
 
   183                       (state1.eid, tr2.eid))
 
   181                       (state1.eid, tr2.eid))
 
   184         self.execute('SET X destination_state Y WHERE X eid %s, Y eid %s' %
 
   182         self.execute('SET X destination_state Y WHERE X eid %s, Y eid %s' %
 
   185                       (tr1.eid, state2.eid))
 
   183                       (tr1.eid, state2.eid))
 
   186         self.execute('SET X destination_state Y WHERE X eid %s, Y eid %s' %
 
   184         self.execute('SET X destination_state Y WHERE X eid %s, Y eid %s' %
 
   187                       (tr2.eid, state2.eid))
 
   185                       (tr2.eid, state2.eid))
 
   188         self.execute('SET X initial_state Y WHERE Y eid %s, X name "Card"' % state1.eid)
 
   186         self.execute('SET X initial_state Y WHERE Y eid %s, X name "CWGroup"' % state1.eid)
 
   189         self.execute('SET X initial_state Y WHERE Y eid %s, X name "Bookmark"' % state1.eid)
 
   187         self.execute('SET X initial_state Y WHERE Y eid %s, X name "Bookmark"' % state1.eid)
 
   190         card = self.add_entity('Card', title=u't1')
 
   188         group = self.add_entity('CWGroup', name=u't1')
 
       
   189         transitions = list(state1.transitions(group))
 
       
   190         self.assertEquals(len(transitions), 1)
 
       
   191         self.assertEquals(transitions[0].name, 'tr1')
 
   191         bookmark = self.add_entity('Bookmark', title=u'111', path=u'/view')
 
   192         bookmark = self.add_entity('Bookmark', title=u'111', path=u'/view')
 
   192         
       
   193         transitions = list(state1.transitions(card))
 
       
   194         self.assertEquals(len(transitions), 1)
 
       
   195         self.assertEquals(transitions[0].name, 'tr1')
 
       
   196         transitions = list(state1.transitions(bookmark))
 
   193         transitions = list(state1.transitions(bookmark))
 
   197         self.assertEquals(len(transitions), 1)
 
   194         self.assertEquals(len(transitions), 1)
 
   198         self.assertEquals(transitions[0].name, 'tr2')
 
   195         self.assertEquals(transitions[0].name, 'tr2')
 
   199         
   196 
   200 
   197 
   201 class EmailAddressTC(BaseEntityTC):
 
   198 class EmailAddressTC(BaseEntityTC):
 
   202     def test_canonical_form(self):
 
   199     def test_canonical_form(self):
 
   203         eid1 = self.execute('INSERT EmailAddress X: X address "maarten.ter.huurne@philips.com"')[0][0]
 
   200         eid1 = self.execute('INSERT EmailAddress X: X address "maarten.ter.huurne@philips.com"')[0][0]
 
   204         eid2 = self.execute('INSERT EmailAddress X: X address "maarten@philips.com", X canonical TRUE')[0][0]
 
   201         eid2 = self.execute('INSERT EmailAddress X: X address "maarten@philips.com", X canonical TRUE')[0][0]
 
   224         self.assertEquals(email.display_address(), 'syt')
 
   221         self.assertEquals(email.display_address(), 'syt')
 
   225         self.assertEquals(email.printable_value('address'), 'syt')
 
   222         self.assertEquals(email.printable_value('address'), 'syt')
 
   226 
   223 
   227 
   224 
   228 class CWUserTC(BaseEntityTC):
 
   225 class CWUserTC(BaseEntityTC):
 
   229     
   226 
   230     def test_complete(self):
 
   227     def test_complete(self):
 
   231         e = self.entity('CWUser X WHERE X login "admin"')
 
   228         e = self.entity('CWUser X WHERE X login "admin"')
 
   232         e.complete()
 
   229         e.complete()
 
   233 
   230 
   234         
   231 
   235     def test_matching_groups(self):
 
   232     def test_matching_groups(self):
 
   236         e = self.entity('CWUser X WHERE X login "admin"')
 
   233         e = self.entity('CWUser X WHERE X login "admin"')
 
   237         self.failUnless(e.matching_groups('managers'))
 
   234         self.failUnless(e.matching_groups('managers'))
 
   238         self.failIf(e.matching_groups('xyz'))
 
   235         self.failIf(e.matching_groups('xyz'))
 
   239         self.failUnless(e.matching_groups(('xyz', 'managers')))
 
   236         self.failUnless(e.matching_groups(('xyz', 'managers')))
 
   273 
   270 
   274     def select_eclass(self, etype):
 
   271     def select_eclass(self, etype):
 
   275         # clear selector cache
 
   272         # clear selector cache
 
   276         clear_cache(self.vreg, 'etype_class')
 
   273         clear_cache(self.vreg, 'etype_class')
 
   277         return self.vreg.etype_class(etype)
 
   274         return self.vreg.etype_class(etype)
 
   278         
   275 
   279     def test_etype_class_selection_and_specialization(self):
 
   276     def test_etype_class_selection_and_specialization(self):
 
   280         # no specific class for Subdivisions, the default one should be selected
 
   277         # no specific class for Subdivisions, the default one should be selected
 
   281         eclass = self.select_eclass('SubDivision')
 
   278         eclass = self.select_eclass('SubDivision')
 
   282         self.failUnless(eclass.__autogenerated__)
 
   279         self.failUnless(eclass.__autogenerated__)
 
   283         #self.assertEquals(eclass.__bases__, (AnyEntity,))
 
   280         #self.assertEquals(eclass.__bases__, (AnyEntity,))
 
   295                 self.failUnless(eclass.__autogenerated__)
 
   292                 self.failUnless(eclass.__autogenerated__)
 
   296                 self.assertEquals(eclass.__bases__, (Foo,))
 
   293                 self.assertEquals(eclass.__bases__, (Foo,))
 
   297         # check Division eclass is still selected for plain Division entities
 
   294         # check Division eclass is still selected for plain Division entities
 
   298         eclass = self.select_eclass('Division')
 
   295         eclass = self.select_eclass('Division')
 
   299         self.assertEquals(eclass.id, 'Division')
 
   296         self.assertEquals(eclass.id, 'Division')
 
   300         
   297 
   301 if __name__ == '__main__':
 
   298 if __name__ == '__main__':
 
   302     unittest_main()
 
   299     unittest_main()
cubicweb