예제 #1
0
 def _listener(self, engine, listener_func):
     try:
         event.listen(engine, 'before_execute', listener_func)
         yield
     finally:
         event.remove(engine, 'before_execute',
                      listener_func)
예제 #2
0
    def attach_ddl_listeners(self):
        # Remove all previously added listeners, so that same listener don't
        # get added twice in situations where class configuration happens in
        # multiple phases (issue #31).
        for listener in self.listeners:
            event.remove(*listener)
        self.listeners = []

        for column in self.processed_columns:
            # This sets up the trigger that keeps the tsvector column up to
            # date.
            if column.type.columns:
                table = column.table
                if self.option(column, 'remove_symbols'):
                    self.add_listener((
                        table,
                        'after_create',
                        self.search_function_ddl(column)
                    ))
                    self.add_listener((
                        table,
                        'after_drop',
                        DDL(str(DropSearchFunctionSQL(column)))
                    ))

                self.add_listener((
                    table,
                    'after_create',
                    self.search_trigger_ddl(column)
                ))
예제 #3
0
def count_queries():
    """Provides a query counter.

    Usage::

        with count_queries() as count:
            do_stuff()
        assert count() == number_of_queries
    """
    def _after_cursor_execute(*args, **kwargs):
        if active_counter[0]:
            active_counter[0][0] += 1

    @contextmanager
    def _counter():
        if active_counter[0]:
            raise RuntimeError('Cannot nest count_queries calls')
        active_counter[0] = counter = [0]
        try:
            yield lambda: counter[0]
        finally:
            active_counter[0] = None

    active_counter = [None]
    event.listen(Engine, 'after_cursor_execute', _after_cursor_execute)
    try:
        yield _counter
    finally:
        event.remove(Engine, 'after_cursor_execute', _after_cursor_execute)
예제 #4
0
def execute_counter(connection, zsa_savepoints, check_constraints):
    """ Count calls to execute
    """
    from contextlib import contextmanager
    from sqlalchemy import event

    class Counter(object):
        def __init__(self):
            self.reset()
            self.conn = connection

        def reset(self):
            self.count = 0

        @contextmanager
        def expect(self, count):
            start = self.count
            yield
            difference = self.count - start
            assert difference == count

    counter = Counter()

    @event.listens_for(connection, 'after_cursor_execute')
    def after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
        # Ignore the testing savepoints
        if zsa_savepoints.state != 'begun' or check_constraints.state == 'checking':
            return
        counter.count += 1

    yield counter

    event.remove(connection, 'after_cursor_execute', after_cursor_execute)
예제 #5
0
def ro_session_tracker(ro_session):
    """
    This install an event handler into the active session, which
    tracks all SQL statements that are send via the session.

    The yielded checker can be called with an integer argument,
    representing the number of expected SQL statements, for example::

        ro_session_tracker(0)

    would only succeed if no SQL statements where made.
    """

    db_events = []

    def scoped_conn_event_handler(calls):
        def conn_event_handler(**kw):
            calls.append((kw['statement'], kw['parameters']))
        return conn_event_handler

    handler = scoped_conn_event_handler(db_events)
    event.listen(ro_session.bind,
                 'before_cursor_execute',
                 handler, named=True)

    def checker(num=None):
        if num is not None:
            assert len(db_events) == num

    yield checker

    event.remove(ro_session.bind, 'before_cursor_execute', handler)
예제 #6
0
    def test_propagate(self):
        Target = self._fixture()

        m1 = Mock()

        t1 = Target()
        t2 = Target()

        event.listen(t1, "event_one", m1, propagate=True)
        event.listen(t1, "event_two", m1, propagate=False)

        t2.dispatch._update(t1.dispatch)

        t1.dispatch.event_one("t1e1x")
        t1.dispatch.event_two("t1e2x")
        t2.dispatch.event_one("t2e1x")
        t2.dispatch.event_two("t2e2x")

        event.remove(t1, "event_one", m1)
        event.remove(t1, "event_two", m1)

        t1.dispatch.event_one("t1e1y")
        t1.dispatch.event_two("t1e2y")
        t2.dispatch.event_one("t2e1y")
        t2.dispatch.event_two("t2e2y")

        eq_(m1.mock_calls,
                [call('t1e1x'), call('t1e2x'),
                call('t2e1x')])
예제 #7
0
    def test_external_tables_not_changed(self):

        def block_external_tables(conn, clauseelement, multiparams, params):
            if isinstance(clauseelement, sqlalchemy.sql.selectable.Select):
                return

            if (isinstance(clauseelement, six.string_types) and
                    any(name in clauseelement for name in external.TABLES)):
                self.fail("External table referenced by neutron core "
                          "migration.")

            if hasattr(clauseelement, 'element'):
                if (clauseelement.element.name in external.TABLES or
                        (hasattr(clauseelement, 'table') and
                         clauseelement.element.table.name in external.TABLES)):
                    self.fail("External table referenced by neutron core "
                              "migration.")

        engine = self.get_engine()
        cfg.CONF.set_override('connection', engine.url, group='database')
        migration.do_alembic_command(self.alembic_config, 'upgrade', 'kilo')

        event.listen(engine, 'before_execute', block_external_tables)
        migration.do_alembic_command(self.alembic_config, 'upgrade', 'heads')

        event.remove(engine, 'before_execute', block_external_tables)
예제 #8
0
    def test_instance(self):
        Target = self._fixture()

        class Foo(object):
            def __init__(self):
                self.mock = Mock()

            def evt(self, arg):
                self.mock(arg)

        f1 = Foo()
        f2 = Foo()

        event.listen(Target, "event_one", f1.evt)
        event.listen(Target, "event_one", f2.evt)

        t1 = Target()
        t1.dispatch.event_one("x")

        event.remove(Target, "event_one", f1.evt)

        t1.dispatch.event_one("y")

        eq_(f1.mock.mock_calls, [call("x")])
        eq_(f2.mock.mock_calls, [call("x"), call("y")])
예제 #9
0
def unregister_fsa_session_signals():
    """Unregisters Flask-SQLAlchemy session commit and rollback signal
    handlers.

    When a Flask-SQLAlchemy object is created, it registers signal handlers for
    ``before_commit``, ``after_commit``, and ``after_rollback`` signals. In
    case of using both a plain SQLAlchemy session and a Flask-SQLAlchemy
    session (as is happening in the tests in this package), we need to
    unregister handlers or there will be some exceptions during test
    executions like::

        AttributeError: 'Session' object has no attribute '_model_changes'

    """
    # We don't need to do this if Flask-SQLAlchemy is not installed.
    if not has_flask_sqlalchemy:
        return
    # We don't need to do this if Flask-SQLAlchemy version 2.0 or
    # greater is installed.
    version = parse_version(flask_sqlalchemy.__version__)
    if version >= (2, 0):
        return
    events = flask_sqlalchemy._SessionSignalEvents
    signal_names = ('before_commit', 'after_commit', 'after_rollback')
    for signal_name in signal_names:
        # For Flask-SQLAlchemy version less than 3.0.
        signal = getattr(events, 'session_signal_{0}'.format(signal_name))
        event.remove(SessionBase, signal_name, signal)
예제 #10
0
    def register(cls, encryptor: Encryptor):
        """
        Register this encryptable with an encryptor.

        Instances of this encryptor will be encrypted on initialization and decrypted on load.

        """
        # save the current encryptor statically
        cls.__encryptor__ = encryptor

        # NB: we cannot use the before_insert listener in conjunction with a foreign key relationship
        # for encrypted data; SQLAlchemy will warn about using 'related attribute set' operation so
        # late in its insert/flush process.
        listeners = dict(
            init=on_init,
            load=on_load,
        )

        for name, func in listeners.items():
            # If we initialize the graph multiple times (as in many unit testing scenarios),
            # we will accumulate listener functions -- with unpredictable results. As protection,
            # we need to remove existing listeners before adding new ones; this solution only
            # works if the id (e.g. memory address) of the listener does not change, which means
            # they cannot be closures around the `encryptor` reference.
            #
            # Hence the `__encryptor__` hack above...
            if contains(cls, name, func):
                remove(cls, name, func)
            listen(cls, name, func)
예제 #11
0
 def remove_sqlalchemy_known_event(self):
     for e, namespace, method in self._sqlalchemy_known_events:
         try:
             event.remove(e.mapper(self, namespace), e.event,
                          method.get_attribute(self))
         except InvalidRequestError:
             pass
예제 #12
0
 def tearDown(self):
     """Roll back the session """
     super(BlokTestCase, self).tearDown()
     self.case_savepoint.rollback()
     self.registry.System.Cache.invalidate_all()
     event.remove(self.registry.session, "after_transaction_end",
                  self.savepoint_restarter)
     self._transaction_case_teared_down = True
예제 #13
0
파일: models.py 프로젝트: yasith/Skvallra
def make_symmetrical(target, value, initiator):
    if value in target.friends:
        raise ValueError

    if target not in value.friends:
        event.remove(User.friends, 'append', make_symmetrical)
        value.friends.append(target)
        event.listen(User.friends, 'append', make_symmetrical)
예제 #14
0
 def tearDown(self):
     """Roll back the session """
     super(BlokTestCase, self).tearDown()
     self.case_savepoint.rollback()
     self.registry.System.Cache.invalidate_all()
     event.remove(self.registry.session, "after_transaction_end",
                  self.savepoint_restarter)
     self._transaction_case_teared_down = True
예제 #15
0
def sqla_remove(*args):
    """Remove SQLA listeners.

    :param args: The args to pass onto remove.
    :returns: None.
    """
    event.remove(*args)
    _REGISTERED_SQLA_EVENTS.remove(args)
예제 #16
0
def drop_db(database_uri=None):
    """ Convenience method for dropping the related tables in the database """
    drop_fnc = DropSchema(SCHEMA_NAME)
    engine = get_engine(database_uri)

    event.listen(Base.metadata, 'after_drop', drop_fnc)
    Base.metadata.drop_all(engine)
    event.remove(Base.metadata, 'after_drop', drop_fnc)
예제 #17
0
def sqla_remove_all():
    for args in _REGISTERED_SQLA_EVENTS:
        try:
            event.remove(*args)
        except sql_exc.InvalidRequestError:
            # already removed
            pass
    del _REGISTERED_SQLA_EVENTS[:]
예제 #18
0
파일: api.py 프로젝트: rajalokan/neutron
def sqla_remove_all():
    for args in _REGISTERED_SQLA_EVENTS:
        try:
            event.remove(*args)
        except sql_exc.InvalidRequestError:
            # already removed
            pass
    del _REGISTERED_SQLA_EVENTS[:]
예제 #19
0
    def before_compile_nobake_fixture(self):
        @event.listens_for(Query, "before_compile", retval=True)
        def _modify_query(query):
            query = query.enable_assertions(False)
            return query

        yield
        event.remove(Query, "before_compile", _modify_query)
예제 #20
0
    def unregister(cls, session):
        if hasattr(session, '_model_changes'):
            del session._model_changes

        event.remove(session, 'before_flush', cls.record_ops)
        event.remove(session, 'before_commit', cls.record_ops)
        event.remove(session, 'before_commit', cls.before_commit)
        event.remove(session, 'after_commit', cls.after_commit)
        event.remove(session, 'after_rollback', cls.after_rollback)
예제 #21
0
 def unregister_events(self):
     try:
         event.remove(self._model_class, 'after_insert',
                      self._db_event_handler)
         event.remove(self._model_class, 'after_delete',
                      self._db_event_handler)
     except sql_exc.InvalidRequestError:
         LOG.warning(_LW("No sqlalchemy event for resource %s found"),
                     self.name)
예제 #22
0
파일: __init__.py 프로젝트: omh/yoshimi
    def count_queries(self):
        self.statements = []

        def catch_queries(conn, cursor, statement, *args):
            self.statements.append(statement)

        event.listen(self.connection, 'before_cursor_execute', catch_queries)
        yield
        event.remove(self.connection, 'before_cursor_execute', catch_queries)
예제 #23
0
파일: __init__.py 프로젝트: omh/yoshimi
    def count_queries(self):
        self.statements = []

        def catch_queries(conn, cursor, statement, *args):
            self.statements.append(statement)

        event.listen(self.connection, 'before_cursor_execute', catch_queries)
        yield
        event.remove(self.connection, 'before_cursor_execute', catch_queries)
예제 #24
0
 def __exit__(self, exc_type, exc_value, traceback):
     event.remove(self.engine, "handle_error", handler_bulk_insert_error)
     if self.enable_fast_executemany is True:
         event.remove(self.engine, "before_cursor_execute",
                      handler_fast_executemany)
     if traceback is None:
         duration = time() - self.start_time
         logger.info(
             f'{self.table_name} insert took {duration:.2f} seconds')
예제 #25
0
 def test_remove_instancelevel(self):
     listen_one = Mock()
     t1 = self.Target()
     event.listen(t1, "event_one", listen_one, add=True)
     t1.dispatch.event_one(5, 7)
     eq_(listen_one.mock_calls, [call(12)])
     event.remove(t1, "event_one", listen_one)
     t1.dispatch.event_one(10, 5)
     eq_(listen_one.mock_calls, [call(12)])
예제 #26
0
    def unregister(cls, session):
        if hasattr(session, '_model_changes'):
            del session._model_changes

        event.remove(session, 'before_flush', cls.record_ops)
        event.remove(session, 'before_commit', cls.record_ops)
        event.remove(session, 'before_commit', cls.before_commit)
        event.remove(session, 'after_commit', cls.after_commit)
        event.remove(session, 'after_rollback', cls.after_rollback)
예제 #27
0
 def stop(self):
     """Stops the ``before_cursor_execute`` event listener"""
     if self._query_hook:
         sqla_event.remove(self._connectable, 'before_cursor_execute',
                           self._query_hook)
         self._query_hook = None
     if self._replace_new_patch_aliases_config:
         self._replace_new_patch_aliases_config.__exit__(None, None, None)
         self._replace_new_patch_aliases_config = None
예제 #28
0
파일: resource.py 프로젝트: MODITDC/neutron
 def unregister_events(self):
     try:
         event.remove(self._model_class, 'after_insert',
                      self._db_event_handler)
         event.remove(self._model_class, 'after_delete',
                      self._db_event_handler)
     except sql_exc.InvalidRequestError:
         LOG.warning(_LW("No sqlalchemy event for resource %s found"),
                     self.name)
    def unregister(cls, session):
        if hasattr(session, "_model_changes"):
            del session._model_changes

        event.remove(session, "before_flush", cls.record_ops)
        event.remove(session, "before_commit", cls.record_ops)
        event.remove(session, "before_commit", cls.before_commit)
        event.remove(session, "after_commit", cls.after_commit)
        event.remove(session, "after_rollback", cls.after_rollback)
예제 #30
0
    def unregister(cls, session):
        if hasattr(session, "_model_changes"):
            del session._model_changes

        event.remove(session, "before_flush", cls.record_ops)
        event.remove(session, "before_commit", cls.record_ops)
        event.remove(session, "before_commit", cls.before_commit)
        event.remove(session, "after_commit", cls.after_commit)
        event.remove(session, "after_rollback", cls.after_rollback)
예제 #31
0
 def test_remove_instancelevel(self):
     listen_one = Mock()
     t1 = self.Target()
     event.listen(t1, "event_one", listen_one, add=True)
     t1.dispatch.event_one(5, 7)
     eq_(listen_one.mock_calls, [call(12)])
     event.remove(t1, "event_one", listen_one)
     t1.dispatch.event_one(10, 5)
     eq_(listen_one.mock_calls, [call(12)])
예제 #32
0
    def on_dispose(self):
        assert self.linked
        self.linked = False

        event.remove(self.child_rel_prop, 'set', self.on_key_update)

        self.parent_obj = None
        self.child_cls = None
        self.child_rel_name = None
        self.child_rel_prop = None
예제 #33
0
def create_db(database_uri=None):
    """ Creates the schema in the database """
    create_fnc = CreateSchema(SCHEMA_NAME)
    engine = get_engine(database_uri)

    event.listen(Base.metadata, 'before_create', create_fnc)
    Base.metadata.create_all(engine)
    event.remove(Base.metadata, 'before_create', create_fnc)

    return engine
예제 #34
0
def query_recorder(app_config):
    recorder = QueryRecorder()

    engine = app_config.registry["sqlalchemy.engine"]
    event.listen(engine, "before_cursor_execute", recorder.record)

    try:
        yield recorder
    finally:
        event.remove(engine, "before_cursor_execute", recorder.record)
예제 #35
0
    def __declare_last__(cls):
        # Unconfigure the event set in _SQLAMutationTracker, we have _save_data
        mapper = cls._sa_class_manager.mapper
        args = (mapper.attrs['data'], 'set', _SQLAMutationTracker._field_set)
        if event.contains(*args):
            event.remove(*args)

        # Declaring the event on the class attribute instead of mapper property
        # enables proper registration on its subclasses
        event.listen(cls.data, 'set', cls._set_data, retval=True)
예제 #36
0
    def __declare_last__(cls):
        # Unconfigure the event set in _SQLAMutationTracker, we have _save_data
        mapper = cls._sa_class_manager.mapper
        args = (mapper.attrs['data'], 'set', _SQLAMutationTracker._field_set)
        if event.contains(*args):
            event.remove(*args)

        # Declaring the event on the class attribute instead of mapper property
        # enables proper registration on its subclasses
        event.listen(cls.data, 'set', cls._save_data, retval=True)
예제 #37
0
def query_recorder(app_config):
    recorder = QueryRecorder()

    engine = app_config.registry["sqlalchemy.engine"]
    event.listen(engine, "before_cursor_execute", recorder.record)

    try:
        yield recorder
    finally:
        event.remove(engine, "before_cursor_execute", recorder.record)
예제 #38
0
def statements(db):
    stmts = []

    def catch_queries(conn, cursor, statement, parameters, context,
                      executemany):
        stmts.append(statement)

    event.listen(db.engine, "before_cursor_execute", catch_queries)
    yield stmts
    event.remove(db.engine, "before_cursor_execute", catch_queries)
예제 #39
0
def setUpPackage():
    """Setup the plugin."""
    from default import flask_app
    with flask_app.app_context():
        plugin_dir = os.path.dirname(plugin.__file__)
        plugin.LibCrowdsStatistics(plugin_dir).setup()

        # Remove event listeners
        func = event_listeners.record_new_task_run_ip_event
        event.remove(TaskRun, 'before_insert', func)
예제 #40
0
파일: sql.py 프로젝트: gooftroop/Zeus
    def registered(target, event, callback):
        if not target:
            raise IllegalArgumentException("'target' is requried")

        if not event:
            raise IllegalArgumentException("'event' is requried")

        if not callback:
            raise IllegalArgumentException("'callback' is requried")

        event.remove(targe, event, callback)
예제 #41
0
    def test_event_no_native_float(self):
        def _remove_type(inputsizes, cursor, statement, parameters, context):
            for param, dbapitype in list(inputsizes.items()):
                if dbapitype is testing.db.dialect.dbapi.NATIVE_FLOAT:
                    del inputsizes[param]

        event.listen(testing.db, "do_setinputsizes", _remove_type)
        try:
            self._test_setinputsizes(oracle.BINARY_FLOAT, 25.34534, None)
        finally:
            event.remove(testing.db, "do_setinputsizes", _remove_type)
예제 #42
0
    def test_event_no_native_float(self):
        def _remove_type(inputsizes, cursor, statement, parameters, context):
            for param, dbapitype in list(inputsizes.items()):
                if dbapitype is testing.db.dialect.dbapi.NATIVE_FLOAT:
                    del inputsizes[param]

        event.listen(testing.db, "do_setinputsizes", _remove_type)
        try:
            self.test_setinputsizes(oracle.BINARY_FLOAT, 25.34534, None, False)
        finally:
            event.remove(testing.db, "do_setinputsizes", _remove_type)
예제 #43
0
파일: env.py 프로젝트: gonicus/gosa
 def remove_flush_listeners(self):
     """
     remove all before_flush listeners, currently this is only use by a test,
     that switched between proxied and normal mode.
     """
     for session in self.__db_session.values():
         if event.contains(session, "before_flush", before_proxy_flush):
             event.remove(session, "before_flush", before_proxy_flush)
     self.__db_session = {}
     for factory in self.__db_factory.values():
         factory.reset_events()
예제 #44
0
    def unfreeze(self):
        """Stop modifying timestamps in queries."""
        if self._query_hook:
            sa_event.remove(self._connectable, 'before_cursor_execute',
                            self._query_hook)
            self._query_hook = None

        if self._freeze_time is not None:
            self._freeze_time.stop()
            self._freeze_time = None
            self._freezer_factory = None
예제 #45
0
    def test_remove_invoke_clslevel(self):
        canary = Mock()

        event.listen(self.BaseTarget, "event_one", canary)

        s1 = self.SubTarget(self.BaseTarget())

        event.remove(self.BaseTarget, "event_one", canary)

        s1.dispatch.event_one()

        eq_(canary.mock_calls, [])
예제 #46
0
 def register_events(self, remove=False):
     for e, h in (
         ('before_insert', self.before_insert),
         ('before_update', self.before_update),
         ('before_delete', self.before_delete),
     ):
         is_event_exist = event.contains(self.base_class, e, h)
         if remove and is_event_exist:
             event.remove(self.base_class, e, h)
         elif not is_event_exist:
             event.listen(self.base_class, e, h, propagate=True)
     return self
예제 #47
0
def sqla_remove_all():
    """Removes all SQLA listeners.

    :returns: None.
    """
    for args in _REGISTERED_SQLA_EVENTS:
        try:
            event.remove(*args)
        except sql_exc.InvalidRequestError:
            # already removed
            pass
    del _REGISTERED_SQLA_EVENTS[:]
예제 #48
0
    def test_remove_invoke_clslevel(self):
        canary = Mock()

        event.listen(self.BaseTarget, "event_one", canary)

        s1 = self.SubTarget(self.BaseTarget())

        event.remove(self.BaseTarget, "event_one", canary)

        s1.dispatch.event_one()

        eq_(canary.mock_calls, [])
예제 #49
0
    def test_remove_wrapped_named(self):
        Target = self._wrapped_fixture()

        listen_one = Mock()
        t1 = Target()
        event.listen(t1, "event_one", listen_one, named=True)
        t1.dispatch.event_one("t1")

        eq_(listen_one.mock_calls, [call(x="adapted t1")])
        event.remove(t1, "event_one", listen_one)
        t1.dispatch.event_one("t2")

        eq_(listen_one.mock_calls, [call(x="adapted t1")])
예제 #50
0
    def test_remove_wrapped_named(self):
        Target = self._wrapped_fixture()

        listen_one = Mock()
        t1 = Target()
        event.listen(t1, "event_one", listen_one, named=True)
        t1.dispatch.event_one("t1")

        eq_(listen_one.mock_calls, [call(x="adapted t1")])
        event.remove(t1, "event_one", listen_one)
        t1.dispatch.event_one("t2")

        eq_(listen_one.mock_calls, [call(x="adapted t1")])
예제 #51
0
    def commit(self):
        """Commit profiling session.

        :raises AssertionError: When the session is not alive.

        """
        if not self.alive:
            raise AssertionError("Profiling session is already committed")

        self.alive = False
        self._get_stats()

        event.remove(self.engine, self._before, self._before_cursor_execute)
        event.remove(self.engine, self._after, self._after_cursor_execute)
예제 #52
0
  def close(self):
    ''' Overrides the QWidget.close. '''
    # Unsubscribe to database events.
    for cls in [model.ArchitectureBlock, model.View, model.Requirement, model.Bug,
                model.FunctionPoint]:
      try:
        event.remove(cls, 'after_update', self.onDetailUpdate)
        event.remove(cls, 'after_insert', self.onDetailInsert)
      except sqlalchemy.exc.InvalidRequestError:
        # No event handlers were found: ignore.
        pass
    self.hasEvents = False

    ViewerWithTreeBase.close(self)
예제 #53
0
    def test_clslevel(self):
        Target = self._fixture()

        m1 = Mock()

        event.listen(Target, "event_two", m1)

        t1 = Target()
        t1.dispatch.event_two("x")

        event.remove(Target, "event_two", m1)

        t1.dispatch.event_two("y")

        eq_(m1.mock_calls, [call("x")])
예제 #54
0
def untrace_sqlalchemy():
    try:
        args = []
        for key in event.registry._key_to_collection:
            identifier = key[1]
            if identifier not in ('before_cursor_execute',
                                  'after_cursor_execute', 'handle_error'):
                continue
            fn = ctypes.cast(key[2], ctypes.py_object).value
            args.append([identifier, fn])

        for arg in args:
            event.remove(Engine, *arg)
    except Exception:
        pass
예제 #55
0
    def test_clslevel(self):
        Target = self._fixture()

        m1 = Mock()

        event.listen(Target, "event_two", m1)

        t1 = Target()
        t1.dispatch.event_two("x")

        event.remove(Target, "event_two", m1)

        t1.dispatch.event_two("y")

        eq_(m1.mock_calls, [call("x")])
예제 #56
0
    def connection(self, sync_engine, setup_schema):
        def restart(session, transaction):
            nonlocal nested
            if not nested.is_active:
                nested = conn.begin_nested()

        conn = sync_engine.connect()
        tx = conn.begin()
        nested = conn.begin_nested()
        event.listen(Session, "after_transaction_end", restart)

        yield conn

        event.remove(Session, "after_transaction_end", restart)
        nested.rollback()
        tx.rollback()
예제 #57
0
def no_deps(conn, DBSession):
    from sqlalchemy import event

    session = DBSession()

    @event.listens_for(session, 'after_flush')
    def check_dependencies(session, flush_context):
        assert not flush_context.cycles

    @event.listens_for(conn, "before_execute", retval=True)
    def before_execute(conn, clauseelement, multiparams, params):
        return clauseelement, multiparams, params

    yield

    event.remove(session, 'before_flush', check_dependencies)
예제 #58
0
    def test_remove_not_listened(self):
        Target = self._fixture()

        m1 = Mock()

        t1 = Target()

        event.listen(t1, "event_one", m1, propagate=True)
        event.listen(t1, "event_three", m1)

        event.remove(t1, "event_one", m1)
        assert_raises_message(
            exc.InvalidRequestError,
            r"No listeners found for event <.*Target.*> / 'event_two' / <Mock.*> ",
            event.remove, t1, "event_two", m1)

        event.remove(t1, "event_three", m1)
예제 #59
0
 def __exit__(self, exc_type, exc_value, exc_traceback):
     event.remove(*self._sql_listen_args)
     if exc_type is not None:
         return False
     if self.test_id:
         limit_msg = ((' Limit: %d.' % self.max_count)
                      if self.max_count is not None else '')
         logging.info('%s executed %d queries.%s', self.test_id,
                      len(self.queries), limit_msg)
     if self.max_count is None:
         return
     if len(self.queries) > self.max_count:
         message = ('Maximum query count exceeded: limit %d, executed %d.\n'
                    '----QUERIES----\n%s\n----END----') % (
                        self.max_count, len(self.queries), '\n'.join(
                            self.queries))
         raise AssertionError(message)
예제 #60
0
    def clear(self):
        logger.info(
            f"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ clearing Syned Models"
        )
        for nr, ev in enumerate(
            ['after_insert', 'after_update', 'after_delete']):
            for model in self.models:
                listener = self.model_handlers[model]
                logger.info(f"remove listener {listener} for {model} on {ev}")

                if event.contains(model, ev, listener[nr]):
                    event.remove(model, ev, listener[nr])

        self.models.clear()
        self.model_names.clear()
        self.tables.clear()
        self.ids.clear()