server/test/unittest_repository.py
changeset 7791 31bb51ea5485
parent 7723 badfd5524ab6
child 7795 b8027b317d1c
equal deleted inserted replaced
7790:7e16e056eecb 7791:31bb51ea5485
    96         self.assertEqual(len(person._unique_together), 1)
    96         self.assertEqual(len(person._unique_together), 1)
    97         self.assertItemsEqual(person._unique_together[0],
    97         self.assertItemsEqual(person._unique_together[0],
    98                                            ('nom', 'prenom', 'inline2'))
    98                                            ('nom', 'prenom', 'inline2'))
    99 
    99 
   100     def test_all_entities_have_owner(self):
   100     def test_all_entities_have_owner(self):
   101         self.failIf(self.execute('Any X WHERE NOT X owned_by U'))
   101         self.assertFalse(self.execute('Any X WHERE NOT X owned_by U'))
   102 
   102 
   103     def test_all_entities_have_is(self):
   103     def test_all_entities_have_is(self):
   104         self.failIf(self.execute('Any X WHERE NOT X is ET'))
   104         self.assertFalse(self.execute('Any X WHERE NOT X is ET'))
   105 
   105 
   106     def test_all_entities_have_cw_source(self):
   106     def test_all_entities_have_cw_source(self):
   107         self.failIf(self.execute('Any X WHERE NOT X cw_source S'))
   107         self.assertFalse(self.execute('Any X WHERE NOT X cw_source S'))
   108 
   108 
   109     def test_connect(self):
   109     def test_connect(self):
   110         cnxid = self.repo.connect(self.admlogin, password=self.admpassword)
   110         cnxid = self.repo.connect(self.admlogin, password=self.admpassword)
   111         self.assert_(cnxid)
   111         self.assert_(cnxid)
   112         self.repo.close(cnxid)
   112         self.repo.close(cnxid)
   145         cnxid = self.repo.connect(self.admlogin, password=self.admpassword)
   145         cnxid = self.repo.connect(self.admlogin, password=self.admpassword)
   146         self.repo.execute(cnxid,
   146         self.repo.execute(cnxid,
   147                           'INSERT CWUser X: X login %(login)s, X upassword %(passwd)s',
   147                           'INSERT CWUser X: X login %(login)s, X upassword %(passwd)s',
   148                           {'login': u"tutetute", 'passwd': 'tutetute'})
   148                           {'login': u"tutetute", 'passwd': 'tutetute'})
   149         self.assertRaises(ValidationError, self.repo.commit, cnxid)
   149         self.assertRaises(ValidationError, self.repo.commit, cnxid)
   150         self.failIf(self.repo.execute(cnxid, 'CWUser X WHERE X login "tutetute"'))
   150         self.assertFalse(self.repo.execute(cnxid, 'CWUser X WHERE X login "tutetute"'))
   151         self.repo.close(cnxid)
   151         self.repo.close(cnxid)
   152 
   152 
   153     def test_rollback_on_execute_validation_error(self):
   153     def test_rollback_on_execute_validation_error(self):
   154         class ValidationErrorAfterHook(Hook):
   154         class ValidationErrorAfterHook(Hook):
   155             __regid__ = 'valerror-after-hook'
   155             __regid__ = 'valerror-after-hook'
   158             def __call__(self):
   158             def __call__(self):
   159                 raise ValidationError(self.entity.eid, {})
   159                 raise ValidationError(self.entity.eid, {})
   160         with self.temporary_appobjects(ValidationErrorAfterHook):
   160         with self.temporary_appobjects(ValidationErrorAfterHook):
   161             self.assertRaises(ValidationError,
   161             self.assertRaises(ValidationError,
   162                               self.execute, 'SET X name "toto" WHERE X is CWGroup, X name "guests"')
   162                               self.execute, 'SET X name "toto" WHERE X is CWGroup, X name "guests"')
   163             self.failUnless(self.execute('Any X WHERE X is CWGroup, X name "toto"'))
   163             self.assertTrue(self.execute('Any X WHERE X is CWGroup, X name "toto"'))
   164             with self.assertRaises(QueryError) as cm:
   164             with self.assertRaises(QueryError) as cm:
   165                 self.commit()
   165                 self.commit()
   166             self.assertEqual(str(cm.exception), 'transaction must be rollbacked')
   166             self.assertEqual(str(cm.exception), 'transaction must be rollbacked')
   167             self.rollback()
   167             self.rollback()
   168             self.failIf(self.execute('Any X WHERE X is CWGroup, X name "toto"'))
   168             self.assertFalse(self.execute('Any X WHERE X is CWGroup, X name "toto"'))
   169 
   169 
   170     def test_rollback_on_execute_unauthorized(self):
   170     def test_rollback_on_execute_unauthorized(self):
   171         class UnauthorizedAfterHook(Hook):
   171         class UnauthorizedAfterHook(Hook):
   172             __regid__ = 'unauthorized-after-hook'
   172             __regid__ = 'unauthorized-after-hook'
   173             __select__ = Hook.__select__ & is_instance('CWGroup')
   173             __select__ = Hook.__select__ & is_instance('CWGroup')
   175             def __call__(self):
   175             def __call__(self):
   176                 raise Unauthorized()
   176                 raise Unauthorized()
   177         with self.temporary_appobjects(UnauthorizedAfterHook):
   177         with self.temporary_appobjects(UnauthorizedAfterHook):
   178             self.assertRaises(Unauthorized,
   178             self.assertRaises(Unauthorized,
   179                               self.execute, 'SET X name "toto" WHERE X is CWGroup, X name "guests"')
   179                               self.execute, 'SET X name "toto" WHERE X is CWGroup, X name "guests"')
   180             self.failUnless(self.execute('Any X WHERE X is CWGroup, X name "toto"'))
   180             self.assertTrue(self.execute('Any X WHERE X is CWGroup, X name "toto"'))
   181             with self.assertRaises(QueryError) as cm:
   181             with self.assertRaises(QueryError) as cm:
   182                 self.commit()
   182                 self.commit()
   183             self.assertEqual(str(cm.exception), 'transaction must be rollbacked')
   183             self.assertEqual(str(cm.exception), 'transaction must be rollbacked')
   184             self.rollback()
   184             self.rollback()
   185             self.failIf(self.execute('Any X WHERE X is CWGroup, X name "toto"'))
   185             self.assertFalse(self.execute('Any X WHERE X is CWGroup, X name "toto"'))
   186 
   186 
   187 
   187 
   188     def test_close(self):
   188     def test_close(self):
   189         repo = self.repo
   189         repo = self.repo
   190         cnxid = repo.connect(self.admlogin, password=self.admpassword)
   190         cnxid = repo.connect(self.admlogin, password=self.admpassword)
   362                       initlog=False) # don't reset logging configuration
   362                       initlog=False) # don't reset logging configuration
   363         try:
   363         try:
   364             cnx.load_appobjects(subpath=('entities',))
   364             cnx.load_appobjects(subpath=('entities',))
   365             # check we can get the schema
   365             # check we can get the schema
   366             schema = cnx.get_schema()
   366             schema = cnx.get_schema()
   367             self.failUnless(cnx.vreg)
   367             self.assertTrue(cnx.vreg)
   368             self.failUnless('etypes'in cnx.vreg)
   368             self.assertTrue('etypes'in cnx.vreg)
   369             cu = cnx.cursor()
   369             cu = cnx.cursor()
   370             rset = cu.execute('Any U,G WHERE U in_group G')
   370             rset = cu.execute('Any U,G WHERE U in_group G')
   371             user = iter(rset.entities()).next()
   371             user = iter(rset.entities()).next()
   372             self.failUnless(user._cw)
   372             self.assertTrue(user._cw)
   373             self.failUnless(user._cw.vreg)
   373             self.assertTrue(user._cw.vreg)
   374             from cubicweb.entities import authobjs
   374             from cubicweb.entities import authobjs
   375             self.assertIsInstance(user._cw.user, authobjs.CWUser)
   375             self.assertIsInstance(user._cw.user, authobjs.CWUser)
   376             cnx.close()
   376             cnx.close()
   377             done.append(True)
   377             done.append(True)
   378         finally:
   378         finally:
   423         self.assertRaises(BadConnectionId, repo.set_shared_data, cnxid, 'data', 0)
   423         self.assertRaises(BadConnectionId, repo.set_shared_data, cnxid, 'data', 0)
   424         self.assertRaises(BadConnectionId, repo.get_shared_data, cnxid, 'data')
   424         self.assertRaises(BadConnectionId, repo.get_shared_data, cnxid, 'data')
   425 
   425 
   426     def test_schema_is_relation(self):
   426     def test_schema_is_relation(self):
   427         no_is_rset = self.execute('Any X WHERE NOT X is ET')
   427         no_is_rset = self.execute('Any X WHERE NOT X is ET')
   428         self.failIf(no_is_rset, no_is_rset.description)
   428         self.assertFalse(no_is_rset, no_is_rset.description)
   429 
   429 
   430 #     def test_perfo(self):
   430 #     def test_perfo(self):
   431 #         self.set_debug(True)
   431 #         self.set_debug(True)
   432 #         from time import time, clock
   432 #         from time import time, clock
   433 #         t, c = time(), clock()
   433 #         t, c = time(), clock()
   507             __regid__ = 'dummy-before-hook'
   507             __regid__ = 'dummy-before-hook'
   508             __select__ = Hook.__select__ & is_instance('Affaire')
   508             __select__ = Hook.__select__ & is_instance('Affaire')
   509             events = ('before_update_entity',)
   509             events = ('before_update_entity',)
   510             def __call__(self):
   510             def __call__(self):
   511                 # invoiced attribute shouldn't be considered "edited" before the hook
   511                 # invoiced attribute shouldn't be considered "edited" before the hook
   512                 self._test.failIf('invoiced' in self.entity.cw_edited,
   512                 self._test.assertFalse('invoiced' in self.entity.cw_edited,
   513                                   'cw_edited cluttered by previous update')
   513                                   'cw_edited cluttered by previous update')
   514                 self.entity.cw_edited['invoiced'] = 10
   514                 self.entity.cw_edited['invoiced'] = 10
   515         with self.temporary_appobjects(DummyBeforeHook):
   515         with self.temporary_appobjects(DummyBeforeHook):
   516             req = self.request()
   516             req = self.request()
   517             req.create_entity('Affaire', ref=u'AFF01')
   517             req.create_entity('Affaire', ref=u'AFF01')
   580         self.commit()
   580         self.commit()
   581         self.assertEqual(len(self.execute('Personne X WHERE X has_text "tutu"')), 1)
   581         self.assertEqual(len(self.execute('Personne X WHERE X has_text "tutu"')), 1)
   582         self.session.set_cnxset()
   582         self.session.set_cnxset()
   583         cu = self.session.system_sql('SELECT mtime FROM entities WHERE eid = %s' % eidp)
   583         cu = self.session.system_sql('SELECT mtime FROM entities WHERE eid = %s' % eidp)
   584         mtime = cu.fetchone()[0]
   584         mtime = cu.fetchone()[0]
   585         self.failUnless(omtime < mtime)
   585         self.assertTrue(omtime < mtime)
   586         self.commit()
   586         self.commit()
   587         date, modified, deleted = self.repo.entities_modified_since(('Personne',), omtime)
   587         date, modified, deleted = self.repo.entities_modified_since(('Personne',), omtime)
   588         self.assertEqual(modified, [('Personne', eidp)])
   588         self.assertEqual(modified, [('Personne', eidp)])
   589         self.assertEqual(deleted, [])
   589         self.assertEqual(deleted, [])
   590         date, modified, deleted = self.repo.entities_modified_since(('Personne',), mtime)
   590         date, modified, deleted = self.repo.entities_modified_since(('Personne',), mtime)
   625         self.assertEqual(rset.rows, [[req.user.eid]])
   625         self.assertEqual(rset.rows, [[req.user.eid]])
   626 
   626 
   627     def test_no_uncessary_ftiindex_op(self):
   627     def test_no_uncessary_ftiindex_op(self):
   628         req = self.request()
   628         req = self.request()
   629         req.create_entity('Workflow', name=u'dummy workflow', description=u'huuuuu')
   629         req.create_entity('Workflow', name=u'dummy workflow', description=u'huuuuu')
   630         self.failIf(any(x for x in self.session.pending_operations
   630         self.assertFalse(any(x for x in self.session.pending_operations
   631                         if isinstance(x, native.FTIndexEntityOp)))
   631                         if isinstance(x, native.FTIndexEntityOp)))
   632 
   632 
   633 
   633 
   634 class DBInitTC(CubicWebTC):
   634 class DBInitTC(CubicWebTC):
   635 
   635