devtools/repotest.py
changeset 9833 1485aab7ece6
parent 9831 db4aeba5d336
child 9834 807f7a6f33f4
equal deleted inserted replaced
9832:17abdb7af3e6 9833:1485aab7ece6
     1 # copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
     1 # copyright 2003-2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
     2 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
     2 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
     3 #
     3 #
     4 # This file is part of CubicWeb.
     4 # This file is part of CubicWeb.
     5 #
     5 #
     6 # CubicWeb is free software: you can redistribute it and/or modify it under the
     6 # CubicWeb is free software: you can redistribute it and/or modify it under the
    20 This module contains functions to initialize a new repository.
    20 This module contains functions to initialize a new repository.
    21 """
    21 """
    22 
    22 
    23 __docformat__ = "restructuredtext en"
    23 __docformat__ = "restructuredtext en"
    24 
    24 
    25 from copy import deepcopy
       
    26 from pprint import pprint
    25 from pprint import pprint
    27 
    26 
    28 from logilab.common.decorators import clear_cache
       
    29 from logilab.common.testlib import SkipTest
    27 from logilab.common.testlib import SkipTest
    30 
    28 
    31 def tuplify(list):
    29 def tuplify(list):
    32     for i in range(len(list)):
    30     for i in range(len(list)):
    33         if type(list[i]) is not type(()):
    31         if type(list[i]) is not type(()):
   202         self.o = self.repo.querier
   200         self.o = self.repo.querier
   203         self.session = self.repo._sessions.values()[0]
   201         self.session = self.repo._sessions.values()[0]
   204         self.ueid = self.session.user.eid
   202         self.ueid = self.session.user.eid
   205         assert self.ueid != -1
   203         assert self.ueid != -1
   206         self.repo._type_source_cache = {} # clear cache
   204         self.repo._type_source_cache = {} # clear cache
   207         self.cnxset = self.session.set_cnxset()
       
   208         self.maxeid = self.get_max_eid()
   205         self.maxeid = self.get_max_eid()
   209         do_monkey_patch()
   206         do_monkey_patch()
   210         self._dumb_sessions = []
   207         self._dumb_sessions = []
   211 
   208 
   212     def get_max_eid(self):
   209     def get_max_eid(self):
   213         return self.session.execute('Any MAX(X)')[0][0]
   210         with self.session.new_cnx() as cnx:
       
   211             return cnx.execute('Any MAX(X)')[0][0]
       
   212 
   214     def cleanup(self):
   213     def cleanup(self):
   215         self.session.set_cnxset()
   214         with self.session.new_cnx() as cnx:
   216         self.session.execute('DELETE Any X WHERE X eid > %s' % self.maxeid)
   215             cnx.execute('DELETE Any X WHERE X eid > %s' % self.maxeid)
       
   216             cnx.commit()
   217 
   217 
   218     def tearDown(self):
   218     def tearDown(self):
   219         undo_monkey_patch()
   219         undo_monkey_patch()
   220         self.session.rollback()
       
   221         self.cleanup()
   220         self.cleanup()
   222         self.commit()
       
   223         # properly close dumb sessions
       
   224         for session in self._dumb_sessions:
       
   225             session.rollback()
       
   226             session.close()
       
   227         self.repo._free_cnxset(self.cnxset)
       
   228         assert self.session.user.eid != -1
   221         assert self.session.user.eid != -1
   229 
   222 
   230     def set_debug(self, debug):
   223     def set_debug(self, debug):
   231         set_debug(debug)
   224         set_debug(debug)
   232     def debugged(self, debug):
   225     def debugged(self, debug):
   257         return rqlst
   250         return rqlst
   258 
   251 
   259     def user_groups_session(self, *groups):
   252     def user_groups_session(self, *groups):
   260         """lightweight session using the current user with hi-jacked groups"""
   253         """lightweight session using the current user with hi-jacked groups"""
   261         # use self.session.user.eid to get correct owned_by relation, unless explicit eid
   254         # use self.session.user.eid to get correct owned_by relation, unless explicit eid
   262         u = self.repo._build_user(self.session, self.session.user.eid)
   255         with self.session.new_cnx() as cnx:
   263         u._groups = set(groups)
   256             u = self.repo._build_user(cnx, self.session.user.eid)
   264         s = Session(u, self.repo)
   257             u._groups = set(groups)
   265         s._cnx.cnxset = self.cnxset
   258             s = Session(u, self.repo)
   266         s._cnx.ctx_count = 1
   259             return s
   267         # register session to ensure it gets closed
       
   268         self._dumb_sessions.append(s)
       
   269         return s
       
   270 
       
   271     def execute(self, rql, args=None, build_descr=True):
       
   272         return self.o.execute(self.session, rql, args, build_descr)
       
   273 
       
   274     def commit(self):
       
   275         self.session.commit()
       
   276         self.session.set_cnxset()
       
   277 
   260 
   278     def qexecute(self, rql, args=None, build_descr=True):
   261     def qexecute(self, rql, args=None, build_descr=True):
   279         with self.session.new_cnx() as cnx:
   262         with self.session.new_cnx() as cnx:
   280             with cnx.ensure_cnx_set:
   263             with cnx.ensure_cnx_set:
   281                 try:
   264                 try:
   289 
   272 
   290     def setup(self):
   273     def setup(self):
   291         # XXX source_defs
   274         # XXX source_defs
   292         self.o = self.repo.querier
   275         self.o = self.repo.querier
   293         self.session = self.repo._sessions.values()[0]
   276         self.session = self.repo._sessions.values()[0]
   294         self.cnxset = self.session.set_cnxset()
       
   295         self.schema = self.o.schema
   277         self.schema = self.o.schema
   296         self.system = self.repo.system_source
   278         self.system = self.repo.system_source
   297         do_monkey_patch()
   279         do_monkey_patch()
   298         self._dumb_sessions = [] # by hi-jacked parent setup
       
   299         self.repo.vreg.rqlhelper.backend = 'postgres' # so FTIRANK is considered
   280         self.repo.vreg.rqlhelper.backend = 'postgres' # so FTIRANK is considered
   300 
   281 
   301     def tearDown(self):
   282     def tearDown(self):
   302         undo_monkey_patch()
   283         undo_monkey_patch()
   303         for session in self._dumb_sessions:
       
   304             if session._cnx.cnxset is not None:
       
   305                 session._cnx.cnxset = None
       
   306             session.close()
       
   307 
   284 
   308     def _prepare_plan(self, rql, kwargs=None):
   285     def _prepare_plan(self, rql, kwargs=None):
   309         rqlst = self.o.parse(rql, annotate=True)
   286         rqlst = self.o.parse(rql, annotate=True)
   310         self.o.solutions(self.session, rqlst, kwargs)
   287         self.o.solutions(self.session, rqlst, kwargs)
   311         if rqlst.TYPE == 'select':
   288         if rqlst.TYPE == 'select':
   361             return (something[0].r_type, something[1])
   338             return (something[0].r_type, something[1])
   362     return _orig_select_principal(scope, relations,
   339     return _orig_select_principal(scope, relations,
   363                                   _sort=lambda rels: sorted(rels, key=sort_key))
   340                                   _sort=lambda rels: sorted(rels, key=sort_key))
   364 
   341 
   365 
   342 
   366 def _merge_input_maps(*args, **kwargs):
       
   367     return sorted(_orig_merge_input_maps(*args, **kwargs))
       
   368 
       
   369 def _choose_term(self, source, sourceterms):
       
   370     # predictable order for test purpose
       
   371     def get_key(x):
       
   372         try:
       
   373             # variable
       
   374             return x.name
       
   375         except AttributeError:
       
   376             try:
       
   377                 # relation
       
   378                 return x.r_type
       
   379             except AttributeError:
       
   380                 # const
       
   381                 return x.value
       
   382     return _orig_choose_term(self, source, DumbOrderedDict2(sourceterms, get_key))
       
   383 
       
   384 def _ordered_iter_relations(stinfo):
   343 def _ordered_iter_relations(stinfo):
   385     return sorted(_orig_iter_relations(stinfo), key=lambda x:x.r_type)
   344     return sorted(_orig_iter_relations(stinfo), key=lambda x:x.r_type)
   386 
   345 
   387 def do_monkey_patch():
   346 def do_monkey_patch():
   388     rqlrewrite.iter_relations = _ordered_iter_relations
   347     rqlrewrite.iter_relations = _ordered_iter_relations