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.
test/unittest_entity.py
changeset 10467 73ea636a5562
parent 10354 635cfac73d28
child 10529 747eded13c68
equal deleted inserted replaced
10466:cf7a1ad9ee42 10467:73ea636a5562 
   232         try:
 
   232         try:
 
   233             with self.admin_access.web_request() as req:
 
   233             with self.admin_access.web_request() as req:
 
   234                 user = req.user
 
   234                 user = req.user
 
   235                 # testing basic fetch_attrs attribute
 
   235                 # testing basic fetch_attrs attribute
 
   236                 self.assertEqual(Personne.fetch_rql(user),
 
   236                 self.assertEqual(Personne.fetch_rql(user),
 
   237                                  'Any X,AA,AB,AC ORDERBY AA '
 
   237                                  'Any X,AA,AB,AC ORDERBY AB '
 
   238                                  'WHERE X is_instance_of Personne, X nom AA, X prenom AB, X modification_date AC')
 
   238                                  'WHERE X is_instance_of Personne, X modification_date AA, X nom AB, X prenom AC')
 
   239                 # testing unknown attributes
 
   239                 # testing unknown attributes
 
   240                 Personne.fetch_attrs = ('bloug', 'beep')
 
   240                 Personne.fetch_attrs = ('bloug', 'beep')
 
   241                 self.assertEqual(Personne.fetch_rql(user), 'Any X WHERE X is_instance_of Personne')
 
   241                 self.assertEqual(Personne.fetch_rql(user), 'Any X WHERE X is_instance_of Personne')
 
   242                 # testing one non final relation
 
   242                 # testing one non final relation
 
   243                 Personne.fetch_attrs = ('nom', 'prenom', 'travaille')
 
   243                 Personne.fetch_attrs = ('nom', 'prenom', 'travaille')
 
   245                                  'Any X,AA,AB,AC,AD ORDERBY AA '
 
   245                                  'Any X,AA,AB,AC,AD ORDERBY AA '
 
   246                                  'WHERE X is_instance_of Personne, X nom AA, X prenom AB, X travaille AC?, AC nom AD')
 
   246                                  'WHERE X is_instance_of Personne, X nom AA, X prenom AB, X travaille AC?, AC nom AD')
 
   247                 # testing two non final relations
 
   247                 # testing two non final relations
 
   248                 Personne.fetch_attrs = ('nom', 'prenom', 'travaille', 'evaluee')
 
   248                 Personne.fetch_attrs = ('nom', 'prenom', 'travaille', 'evaluee')
 
   249                 self.assertEqual(Personne.fetch_rql(user),
 
   249                 self.assertEqual(Personne.fetch_rql(user),
 
   250                                  'Any X,AA,AB,AC,AD,AE ORDERBY AA '
 
   250                                  'Any X,AA,AB,AC,AD,AE ORDERBY AB '
 
   251                                  'WHERE X is_instance_of Personne, X nom AA, X prenom AB, X travaille AC?, AC nom AD, '
 
   251                                  'WHERE X is_instance_of Personne, X evaluee AA?, X nom AB, X prenom AC, X travaille AD?, '
 
   252                                  'X evaluee AE?')
 
   252                                  'AD nom AE')
 
   253                 # testing one non final relation with recursion
 
   253                 # testing one non final relation with recursion
 
   254                 Personne.fetch_attrs = ('nom', 'prenom', 'travaille')
 
   254                 Personne.fetch_attrs = ('nom', 'prenom', 'travaille')
 
   255                 Societe.fetch_attrs = ('nom', 'evaluee')
 
   255                 Societe.fetch_attrs = ('nom', 'evaluee')
 
   256                 self.assertEqual(Personne.fetch_rql(user),
 
   256                 self.assertEqual(Personne.fetch_rql(user),
 
   257                                  'Any X,AA,AB,AC,AD,AE,AF ORDERBY AA,AF DESC '
 
   257                                  'Any X,AA,AB,AC,AD,AE,AF ORDERBY AA,AE DESC '
 
   258                                  'WHERE X is_instance_of Personne, X nom AA, X prenom AB, X travaille AC?, AC nom AD, '
 
   258                                  'WHERE X is_instance_of Personne, X nom AA, X prenom AB, X travaille AC?, '
 
   259                                  'AC evaluee AE?, AE modification_date AF'
 
   259                                  'AC evaluee AD?, AD modification_date AE, AC nom AF')
 
   260                                   )
 
       
   261                 # testing symmetric relation
 
   260                 # testing symmetric relation
 
   262                 Personne.fetch_attrs = ('nom', 'connait')
 
   261                 Personne.fetch_attrs = ('nom', 'connait')
 
   263                 self.assertEqual(Personne.fetch_rql(user), 'Any X,AA,AB ORDERBY AA '
 
   262                 self.assertEqual(Personne.fetch_rql(user), 'Any X,AA,AB ORDERBY AB '
 
   264                                  'WHERE X is_instance_of Personne, X nom AA, X connait AB?')
 
   263                                  'WHERE X is_instance_of Personne, X connait AA?, X nom AB')
 
   265                 # testing optional relation
 
   264                 # testing optional relation
 
   266                 peschema.subjrels['travaille'].rdef(peschema, seschema).cardinality = '?*'
 
   265                 peschema.subjrels['travaille'].rdef(peschema, seschema).cardinality = '?*'
 
   267                 Personne.fetch_attrs = ('nom', 'prenom', 'travaille')
 
   266                 Personne.fetch_attrs = ('nom', 'prenom', 'travaille')
 
   268                 Societe.fetch_attrs = ('nom',)
 
   267                 Societe.fetch_attrs = ('nom',)
 
   269                 self.assertEqual(Personne.fetch_rql(user),
 
   268                 self.assertEqual(Personne.fetch_rql(user),
 
   287         Note.fetch_attrs, Note.cw_fetch_order = fetch_config(('type',))
 
   286         Note.fetch_attrs, Note.cw_fetch_order = fetch_config(('type',))
 
   288         SubNote.fetch_attrs, SubNote.cw_fetch_order = fetch_config(('type',))
 
   287         SubNote.fetch_attrs, SubNote.cw_fetch_order = fetch_config(('type',))
 
   289         with self.admin_access.web_request() as req:
 
   288         with self.admin_access.web_request() as req:
 
   290             p = req.create_entity('Personne', nom=u'pouet')
 
   289             p = req.create_entity('Personne', nom=u'pouet')
 
   291             self.assertEqual(p.cw_related_rql('evaluee'),
 
   290             self.assertEqual(p.cw_related_rql('evaluee'),
 
   292                              'Any X,AA,AB ORDERBY AA WHERE E eid %(x)s, E evaluee X, '
 
   291                              'Any X,AA,AB ORDERBY AB WHERE E eid %(x)s, E evaluee X, '
 
   293                              'X type AA, X modification_date AB')
 
   292                              'X modification_date AA, X type AB')
 
   294             n = req.create_entity('Note')
 
   293             n = req.create_entity('Note')
 
   295             self.assertEqual(n.cw_related_rql('evaluee', role='object',
 
   294             self.assertEqual(n.cw_related_rql('evaluee', role='object',
 
   296                                               targettypes=('Societe', 'Personne')),
 
   295                                               targettypes=('Societe', 'Personne')),
 
   297                              "Any X,AA ORDERBY AB DESC WHERE E eid %(x)s, X evaluee E, "
 
   296                              "Any X,AA ORDERBY AB DESC WHERE E eid %(x)s, X evaluee E, "
 
   298                              "X is IN(Personne, Societe), X nom AA, "
 
   297                              "X is IN(Personne, Societe), X nom AA, "
 
   306             tag = self.vreg['etypes'].etype_class('Tag')(req)
 
   305             tag = self.vreg['etypes'].etype_class('Tag')(req)
 
   307             self.assertEqual(tag.cw_related_rql('tags', 'subject'),
 
   306             self.assertEqual(tag.cw_related_rql('tags', 'subject'),
 
   308                               'Any X,AA ORDERBY AA DESC '
 
   307                               'Any X,AA ORDERBY AA DESC '
 
   309                               'WHERE E eid %(x)s, E tags X, X modification_date AA')
 
   308                               'WHERE E eid %(x)s, E tags X, X modification_date AA')
 
   310             self.assertEqual(tag.cw_related_rql('tags', 'subject', ('Personne',)),
 
   309             self.assertEqual(tag.cw_related_rql('tags', 'subject', ('Personne',)),
 
   311                               'Any X,AA,AB ORDERBY AA '
 
   310                               'Any X,AA,AB ORDERBY AB '
 
   312                               'WHERE E eid %(x)s, E tags X, X is Personne, X nom AA, '
 
   311                               'WHERE E eid %(x)s, E tags X, X is Personne, X modification_date AA, '
 
   313                               'X modification_date AB')
 
   312                               'X nom AB')
 
   314 
   313 
   315     def test_related_rql_ambiguous_cant_use_fetch_order(self):
 
   314     def test_related_rql_ambiguous_cant_use_fetch_order(self):
 
   316         with self.admin_access.web_request() as req:
 
   315         with self.admin_access.web_request() as req:
 
   317             tag = self.vreg['etypes'].etype_class('Tag')(req)
 
   316             tag = self.vreg['etypes'].etype_class('Tag')(req)
 
   318             for ttype in self.schema['tags'].objects():
 
   317             for ttype in self.schema['tags'].objects():
 
   372 
   371 
   373     def test_unrelated_rql_security_2(self):
 
   372     def test_unrelated_rql_security_2(self):
 
   374         with self.admin_access.web_request() as req:
 
   373         with self.admin_access.web_request() as req:
 
   375             email = req.execute('INSERT EmailAddress X: X address "hop"').get_entity(0, 0)
 
   374             email = req.execute('INSERT EmailAddress X: X address "hop"').get_entity(0, 0)
 
   376             rql = email.cw_unrelated_rql('use_email', 'CWUser', 'object')[0]
 
   375             rql = email.cw_unrelated_rql('use_email', 'CWUser', 'object')[0]
 
   377             self.assertEqual(rql, 'Any S,AA,AB,AC,AD ORDERBY AA '
 
   376             self.assertEqual(rql, 'Any S,AA,AB,AC,AD ORDERBY AB '
 
   378                              'WHERE NOT S use_email O, O eid %(x)s, S is_instance_of CWUser, '
 
   377                              'WHERE NOT S use_email O, O eid %(x)s, S is_instance_of CWUser, '
 
   379                              'S login AA, S firstname AB, S surname AC, S modification_date AD')
 
   378                              'S firstname AA, S login AB, S modification_date AC, S surname AD')
 
   380             req.cnx.commit()
 
   379             req.cnx.commit()
 
   381         rperms = self.schema['EmailAddress'].permissions['read']
 
   380         rperms = self.schema['EmailAddress'].permissions['read']
 
   382         clear_cache(self.schema['EmailAddress'], 'get_groups')
 
   381         clear_cache(self.schema['EmailAddress'], 'get_groups')
 
   383         clear_cache(self.schema['EmailAddress'], 'get_rqlexprs')
 
   382         clear_cache(self.schema['EmailAddress'], 'get_rqlexprs')
 
   384         self.schema['EmailAddress'].permissions['read'] = ('managers', 'users', 'guests',)
 
   383         self.schema['EmailAddress'].permissions['read'] = ('managers', 'users', 'guests',)
 
   385         try:
 
   384         try:
 
   386             with self.new_access('anon').web_request() as req:
 
   385             with self.new_access('anon').web_request() as req:
 
   387                 email = req.execute('Any X WHERE X eid %(x)s', {'x': email.eid}).get_entity(0, 0)
 
   386                 email = req.execute('Any X WHERE X eid %(x)s', {'x': email.eid}).get_entity(0, 0)
 
   388                 rql = email.cw_unrelated_rql('use_email', 'CWUser', 'object')[0]
 
   387                 rql = email.cw_unrelated_rql('use_email', 'CWUser', 'object')[0]
 
   389                 self.assertEqual(rql, 'Any S,AA,AB,AC,AD ORDERBY AA '
 
   388                 self.assertEqual(rql, 'Any S,AA,AB,AC,AD ORDERBY AB '
 
   390                              'WHERE NOT S use_email O, O eid %(x)s, S is CWUser, '
 
   389                              'WHERE NOT S use_email O, O eid %(x)s, S is CWUser, '
 
   391                              'S login AA, S firstname AB, S surname AC, S modification_date AD, '
 
   390                              'S firstname AA, S login AB, S modification_date AC, S surname AD, '
 
   392                              'AE eid %(AF)s, EXISTS(S identity AE, NOT AE in_group AG, AG name "guests", AG is CWGroup)')
 
   391                              'AE eid %(AF)s, EXISTS(S identity AE, NOT AE in_group AG, AG name "guests", AG is CWGroup)')
 
   393         finally:
 
   392         finally:
 
   394             clear_cache(self.schema['EmailAddress'], 'get_groups')
 
   393             clear_cache(self.schema['EmailAddress'], 'get_groups')
 
   395             clear_cache(self.schema['EmailAddress'], 'get_rqlexprs')
 
   394             clear_cache(self.schema['EmailAddress'], 'get_rqlexprs')
 
   396             self.schema['EmailAddress'].permissions['read'] = rperms
 
   395             self.schema['EmailAddress'].permissions['read'] = rperms
 
   397 
   396 
   398     def test_cw_linkable_rql(self):
 
   397     def test_cw_linkable_rql(self):
 
   399         with self.admin_access.web_request() as req:
 
   398         with self.admin_access.web_request() as req:
 
   400             email = req.execute('INSERT EmailAddress X: X address "hop"').get_entity(0, 0)
 
   399             email = req.execute('INSERT EmailAddress X: X address "hop"').get_entity(0, 0)
 
   401             rql = email.cw_linkable_rql('use_email', 'CWUser', 'object')[0]
 
   400             rql = email.cw_linkable_rql('use_email', 'CWUser', 'object')[0]
 
   402             self.assertEqual(rql, 'Any S,AA,AB,AC,AD ORDERBY AA '
 
   401             self.assertEqual(rql, 'Any S,AA,AB,AC,AD ORDERBY AB '
 
   403                              'WHERE O eid %(x)s, S is_instance_of CWUser, '
 
   402                              'WHERE O eid %(x)s, S is_instance_of CWUser, '
 
   404                              'S login AA, S firstname AB, S surname AC, S modification_date AD')
 
   403                              'S firstname AA, S login AB, S modification_date AC, S surname AD')
 
   405 
   404 
   406     def test_unrelated_rql_security_nonexistant(self):
 
   405     def test_unrelated_rql_security_nonexistant(self):
 
   407         with self.new_access('anon').web_request() as req:
 
   406         with self.new_access('anon').web_request() as req:
 
   408             email = self.vreg['etypes'].etype_class('EmailAddress')(req)
 
   407             email = self.vreg['etypes'].etype_class('EmailAddress')(req)
 
   409             rql = email.cw_unrelated_rql('use_email', 'CWUser', 'object')[0]
 
   408             rql = email.cw_unrelated_rql('use_email', 'CWUser', 'object')[0]
 
   410             self.assertEqual(rql, 'Any S,AA,AB,AC,AD ORDERBY AA '
 
   409             self.assertEqual(rql, 'Any S,AA,AB,AC,AD ORDERBY AB '
 
   411                          'WHERE S is CWUser, '
 
   410                          'WHERE S is CWUser, '
 
   412                          'S login AA, S firstname AB, S surname AC, S modification_date AD, '
 
   411                          'S firstname AA, S login AB, S modification_date AC, S surname AD, '
 
   413                          'AE eid %(AF)s, EXISTS(S identity AE, NOT AE in_group AG, AG name "guests", AG is CWGroup)')
 
   412                          'AE eid %(AF)s, EXISTS(S identity AE, NOT AE in_group AG, AG name "guests", AG is CWGroup)')
 
   414 
   413 
   415     def test_unrelated_rql_constraints_creation_subject(self):
 
   414     def test_unrelated_rql_constraints_creation_subject(self):
 
   416         with self.admin_access.web_request() as req:
 
   415         with self.admin_access.web_request() as req:
 
   417             person = self.vreg['etypes'].etype_class('Personne')(req)
 
   416             person = self.vreg['etypes'].etype_class('Personne')(req)
 
   418             rql = person.cw_unrelated_rql('connait', 'Personne', 'subject')[0]
 
   417             rql = person.cw_unrelated_rql('connait', 'Personne', 'subject')[0]
 
   419             self.assertEqual(
 
   418             self.assertEqual(
 
   420             rql, 'Any O,AA,AB,AC ORDERBY AC DESC WHERE '
 
   419             rql, 'Any O,AA,AB,AC ORDERBY AA DESC WHERE '
 
   421             'O is_instance_of Personne, O nom AA, O prenom AB, O modification_date AC')
 
   420             'O is_instance_of Personne, O modification_date AA, O nom AB, O prenom AC')
 
   422 
   421 
   423     def test_unrelated_rql_constraints_creation_object(self):
 
   422     def test_unrelated_rql_constraints_creation_object(self):
 
   424         with self.admin_access.web_request() as req:
 
   423         with self.admin_access.web_request() as req:
 
   425             person = self.vreg['etypes'].etype_class('Personne')(req)
 
   424             person = self.vreg['etypes'].etype_class('Personne')(req)
 
   426             rql = person.cw_unrelated_rql('connait', 'Personne', 'object')[0]
 
   425             rql = person.cw_unrelated_rql('connait', 'Personne', 'object')[0]
 
   427             self.assertEqual(
 
   426             self.assertEqual(
 
   428             rql, 'Any S,AA,AB,AC ORDERBY AC DESC WHERE '
 
   427             rql, 'Any S,AA,AB,AC ORDERBY AA DESC WHERE '
 
   429             'S is Personne, S nom AA, S prenom AB, S modification_date AC, '
 
   428             'S is Personne, S modification_date AA, S nom AB, S prenom AC, '
 
   430             'NOT (S connait AD, AD nom "toto"), AD is Personne, '
 
   429             'NOT (S connait AD, AD nom "toto"), AD is Personne, '
 
   431             'EXISTS(S travaille AE, AE nom "tutu")')
 
   430             'EXISTS(S travaille AE, AE nom "tutu")')
 
   432 
   431 
   433     def test_unrelated_rql_security_rel_perms(self):
 
   432     def test_unrelated_rql_security_rel_perms(self):
 
   434         '''check `connait` add permission has no effect for a new entity on the
 
   433         '''check `connait` add permission has no effect for a new entity on the
 
   437         perm_rrqle = RRQLExpression('U has_update_permission S')
 
   436         perm_rrqle = RRQLExpression('U has_update_permission S')
 
   438         with self.temporary_permissions((rdef, {'add': (perm_rrqle,)})):
 
   437         with self.temporary_permissions((rdef, {'add': (perm_rrqle,)})):
 
   439             with self.admin_access.web_request() as req:
 
   438             with self.admin_access.web_request() as req:
 
   440                 person = self.vreg['etypes'].etype_class('Personne')(req)
 
   439                 person = self.vreg['etypes'].etype_class('Personne')(req)
 
   441                 rql = person.cw_unrelated_rql('connait', 'Personne', 'subject')[0]
 
   440                 rql = person.cw_unrelated_rql('connait', 'Personne', 'subject')[0]
 
   442                 self.assertEqual(rql, 'Any O,AA,AB,AC ORDERBY AC DESC WHERE '
 
   441                 self.assertEqual(rql, 'Any O,AA,AB,AC ORDERBY AA DESC WHERE '
 
   443                          'O is_instance_of Personne, O nom AA, O prenom AB, '
 
   442                          'O is_instance_of Personne, O modification_date AA, O nom AB, '
 
   444                          'O modification_date AC')
 
   443                          'O prenom AC')
 
   445 
   444 
   446     def test_unrelated_rql_constraints_edition_subject(self):
 
   445     def test_unrelated_rql_constraints_edition_subject(self):
 
   447         with self.admin_access.web_request() as req:
 
   446         with self.admin_access.web_request() as req:
 
   448             person = req.create_entity('Personne', nom=u'sylvain')
 
   447             person = req.create_entity('Personne', nom=u'sylvain')
 
   449             rql = person.cw_unrelated_rql('connait', 'Personne', 'subject')[0]
 
   448             rql = person.cw_unrelated_rql('connait', 'Personne', 'subject')[0]
 
   450             self.assertEqual(
 
   449             self.assertEqual(
 
   451                 rql, 'Any O,AA,AB,AC ORDERBY AC DESC WHERE '
 
   450                 rql, 'Any O,AA,AB,AC ORDERBY AA DESC WHERE '
 
   452             'NOT S connait O, S eid %(x)s, O is Personne, '
 
   451             'NOT S connait O, S eid %(x)s, O is Personne, '
 
   453             'O nom AA, O prenom AB, O modification_date AC, '
 
   452             'O modification_date AA, O nom AB, O prenom AC, '
 
   454             'NOT S identity O')
 
   453             'NOT S identity O')
 
   455 
   454 
   456     def test_unrelated_rql_constraints_edition_object(self):
 
   455     def test_unrelated_rql_constraints_edition_object(self):
 
   457         with self.admin_access.web_request() as req:
 
   456         with self.admin_access.web_request() as req:
 
   458             person = req.create_entity('Personne', nom=u'sylvain')
 
   457             person = req.create_entity('Personne', nom=u'sylvain')
 
   459             rql = person.cw_unrelated_rql('connait', 'Personne', 'object')[0]
 
   458             rql = person.cw_unrelated_rql('connait', 'Personne', 'object')[0]
 
   460             self.assertEqual(
 
   459             self.assertEqual(
 
   461             rql, 'Any S,AA,AB,AC ORDERBY AC DESC WHERE '
 
   460             rql, 'Any S,AA,AB,AC ORDERBY AA DESC WHERE '
 
   462             'NOT S connait O, O eid %(x)s, S is Personne, '
 
   461             'NOT S connait O, O eid %(x)s, S is Personne, '
 
   463             'S nom AA, S prenom AB, S modification_date AC, '
 
   462             'S modification_date AA, S nom AB, S prenom AC, '
 
   464             'NOT S identity O, NOT (S connait AD, AD nom "toto"), '
 
   463             'NOT S identity O, NOT (S connait AD, AD nom "toto"), '
 
   465             'EXISTS(S travaille AE, AE nom "tutu")')
 
   464             'EXISTS(S travaille AE, AE nom "tutu")')
 
   466 
   465 
   467     def test_unrelated_rql_s_linkto_s(self):
 
   466     def test_unrelated_rql_s_linkto_s(self):
 
   468         with self.admin_access.web_request() as req:
 
   467         with self.admin_access.web_request() as req:
cubicweb