- removes the "on_" prefix.

14 files changed, 336 insertions, 336 deletions

diff --git a/test/base/test_events.py b/test/base/test_events.py
index a7b10946b..e64ec3b81 100644
--- a/test/base/test_events.py
+++ b/test/base/test_events.py
@@ -9,14 +9,14 @@ class TestEvents(TestBase):
     def setUp(self):
         global Target
         
-        assert 'on_event_one' not in event._registrars
-        assert 'on_event_two' not in event._registrars
+        assert 'event_one' not in event._registrars
+        assert 'event_two' not in event._registrars
         
         class TargetEvents(event.Events):
-            def on_event_one(self, x, y):
+            def event_one(self, x, y):
                 pass
             
-            def on_event_two(self, x):
+            def event_two(self, x):
                 pass
                 
         class Target(object):
@@ -29,22 +29,22 @@ class TestEvents(TestBase):
         def listen(x, y):
             pass
         
-        event.listen(Target, "on_event_one", listen)
+        event.listen(Target, "event_one", listen)
         
-        eq_(len(Target().dispatch.on_event_one), 1)
-        eq_(len(Target().dispatch.on_event_two), 0)
+        eq_(len(Target().dispatch.event_one), 1)
+        eq_(len(Target().dispatch.event_two), 0)
 
     def test_register_instance(self):
         def listen(x, y):
             pass
         
         t1 = Target()
-        event.listen(t1, "on_event_one", listen)
+        event.listen(t1, "event_one", listen)
 
-        eq_(len(Target().dispatch.on_event_one), 0)
-        eq_(len(t1.dispatch.on_event_one), 1)
-        eq_(len(Target().dispatch.on_event_two), 0)
-        eq_(len(t1.dispatch.on_event_two), 0)
+        eq_(len(Target().dispatch.event_one), 0)
+        eq_(len(t1.dispatch.event_one), 1)
+        eq_(len(Target().dispatch.event_two), 0)
+        eq_(len(t1.dispatch.event_two), 0)
     
     def test_register_class_instance(self):
         def listen_one(x, y):
@@ -53,22 +53,22 @@ class TestEvents(TestBase):
         def listen_two(x, y):
             pass
 
-        event.listen(Target, "on_event_one", listen_one)
+        event.listen(Target, "event_one", listen_one)
         
         t1 = Target()
-        event.listen(t1, "on_event_one", listen_two)
+        event.listen(t1, "event_one", listen_two)
 
-        eq_(len(Target().dispatch.on_event_one), 1)
-        eq_(len(t1.dispatch.on_event_one), 2)
-        eq_(len(Target().dispatch.on_event_two), 0)
-        eq_(len(t1.dispatch.on_event_two), 0)
+        eq_(len(Target().dispatch.event_one), 1)
+        eq_(len(t1.dispatch.event_one), 2)
+        eq_(len(Target().dispatch.event_two), 0)
+        eq_(len(t1.dispatch.event_two), 0)
         
         def listen_three(x, y):
             pass
         
-        event.listen(Target, "on_event_one", listen_three)
-        eq_(len(Target().dispatch.on_event_one), 2)
-        eq_(len(t1.dispatch.on_event_one), 3)
+        event.listen(Target, "event_one", listen_three)
+        eq_(len(Target().dispatch.event_one), 2)
+        eq_(len(t1.dispatch.event_one), 3)
         
 class TestAcceptTargets(TestBase):
     """Test default target acceptance."""
@@ -77,11 +77,11 @@ class TestAcceptTargets(TestBase):
         global TargetOne, TargetTwo
         
         class TargetEventsOne(event.Events):
-            def on_event_one(self, x, y):
+            def event_one(self, x, y):
                 pass
 
         class TargetEventsTwo(event.Events):
-            def on_event_one(self, x, y):
+            def event_one(self, x, y):
                 pass
                 
         class TargetOne(object):
@@ -111,32 +111,32 @@ class TestAcceptTargets(TestBase):
         def listen_four(x, y):
             pass
             
-        event.listen(TargetOne, "on_event_one", listen_one)
-        event.listen(TargetTwo, "on_event_one", listen_two)
+        event.listen(TargetOne, "event_one", listen_one)
+        event.listen(TargetTwo, "event_one", listen_two)
         
         eq_(
-            list(TargetOne().dispatch.on_event_one),
+            list(TargetOne().dispatch.event_one),
             [listen_one]
         )
 
         eq_(
-            list(TargetTwo().dispatch.on_event_one),
+            list(TargetTwo().dispatch.event_one),
             [listen_two]
         )
 
         t1 = TargetOne()
         t2 = TargetTwo()
 
-        event.listen(t1, "on_event_one", listen_three)
-        event.listen(t2, "on_event_one", listen_four)
+        event.listen(t1, "event_one", listen_three)
+        event.listen(t2, "event_one", listen_four)
         
         eq_(
-            list(t1.dispatch.on_event_one),
+            list(t1.dispatch.event_one),
             [listen_one, listen_three]
         )
 
         eq_(
-            list(t2.dispatch.on_event_one),
+            list(t2.dispatch.event_one),
             [listen_two, listen_four]
         )
         
@@ -154,7 +154,7 @@ class TestCustomTargets(TestBase):
                 else:
                     return None
                     
-            def on_event_one(self, x, y):
+            def event_one(self, x, y):
                 pass
 
         class Target(object):
@@ -167,17 +167,17 @@ class TestCustomTargets(TestBase):
         def listen(x, y):
             pass
         
-        event.listen("one", "on_event_one", listen)
+        event.listen("one", "event_one", listen)
 
         eq_(
-            list(Target().dispatch.on_event_one),
+            list(Target().dispatch.event_one),
             [listen]
         )
         
         assert_raises(
             exc.InvalidRequestError, 
             event.listen,
-            listen, "on_event_one", Target
+            listen, "event_one", Target
         )
         
 class TestListenOverride(TestBase):
@@ -197,7 +197,7 @@ class TestListenOverride(TestBase):
                     
                 event.Events._listen(target, identifier, adapt)
                     
-            def on_event_one(self, x, y):
+            def event_one(self, x, y):
                 pass
 
         class Target(object):
@@ -214,12 +214,12 @@ class TestListenOverride(TestBase):
         def listen_two(x, y):
             result.append((x, y))
         
-        event.listen(Target, "on_event_one", listen_one, add=True)
-        event.listen(Target, "on_event_one", listen_two)
+        event.listen(Target, "event_one", listen_one, add=True)
+        event.listen(Target, "event_one", listen_two)
 
         t1 = Target()
-        t1.dispatch.on_event_one(5, 7)
-        t1.dispatch.on_event_one(10, 5)
+        t1.dispatch.event_one(5, 7)
+        t1.dispatch.event_one(10, 5)
         
         eq_(result,
             [
@@ -232,10 +232,10 @@ class TestPropagate(TestBase):
         global Target
         
         class TargetEvents(event.Events):
-            def on_event_one(self, arg):
+            def event_one(self, arg):
                 pass
             
-            def on_event_two(self, arg):
+            def event_two(self, arg):
                 pass
                 
         class Target(object):
@@ -252,13 +252,13 @@ class TestPropagate(TestBase):
         
         t1 = Target()
         
-        event.listen(t1, "on_event_one", listen_one, propagate=True)
-        event.listen(t1, "on_event_two", listen_two)
+        event.listen(t1, "event_one", listen_one, propagate=True)
+        event.listen(t1, "event_two", listen_two)
 
         t2 = Target()
         
         t2.dispatch._update(t1.dispatch)
         
-        t2.dispatch.on_event_one(t2, 1)
-        t2.dispatch.on_event_two(t2, 2)
+        t2.dispatch.event_one(t2, 1)
+        t2.dispatch.event_two(t2, 2)
         eq_(result, [(t2, 1)])
diff --git a/test/dialect/test_mysql.py b/test/dialect/test_mysql.py
index 0e0f92d3c..7d5cffbe2 100644
--- a/test/dialect/test_mysql.py
+++ b/test/dialect/test_mysql.py
@@ -1281,8 +1281,8 @@ class SQLModeDetectionTest(TestBase):
             cursor.execute("set sql_mode='%s'" % (",".join(modes)))
         e = engines.testing_engine(options={
             'pool_events':[
-                (connect, 'on_first_connect'),
-                (connect, 'on_connect')
+                (connect, 'first_connect'),
+                (connect, 'connect')
             ]
         })
         return e
diff --git a/test/engine/test_ddlevents.py b/test/engine/test_ddlevents.py
index 790bc23bc..fbe77b9dc 100644
--- a/test/engine/test_ddlevents.py
+++ b/test/engine/test_ddlevents.py
@@ -49,7 +49,7 @@ class DDLEventTest(TestBase):
     def test_table_create_before(self):
         table, bind = self.table, self.bind
         canary = self.Canary(table, bind)
-        event.listen(table, 'on_before_create', canary.before_create)
+        event.listen(table, 'before_create', canary.before_create)
 
         table.create(bind)
         assert canary.state == 'before-create'
@@ -59,7 +59,7 @@ class DDLEventTest(TestBase):
     def test_table_create_after(self):
         table, bind = self.table, self.bind
         canary = self.Canary(table, bind)
-        event.listen(table, 'on_after_create', canary.after_create)
+        event.listen(table, 'after_create', canary.after_create)
 
         canary.state = 'skipped'
         table.create(bind)
@@ -70,8 +70,8 @@ class DDLEventTest(TestBase):
     def test_table_create_both(self):
         table, bind = self.table, self.bind
         canary = self.Canary(table, bind)
-        event.listen(table, 'on_before_create', canary.before_create)
-        event.listen(table, 'on_after_create', canary.after_create)
+        event.listen(table, 'before_create', canary.before_create)
+        event.listen(table, 'after_create', canary.after_create)
         
         table.create(bind)
         assert canary.state == 'after-create'
@@ -81,7 +81,7 @@ class DDLEventTest(TestBase):
     def test_table_drop_before(self):
         table, bind = self.table, self.bind
         canary = self.Canary(table, bind)
-        event.listen(table, 'on_before_drop', canary.before_drop)
+        event.listen(table, 'before_drop', canary.before_drop)
 
         table.create(bind)
         assert canary.state is None
@@ -91,7 +91,7 @@ class DDLEventTest(TestBase):
     def test_table_drop_after(self):
         table, bind = self.table, self.bind
         canary = self.Canary(table, bind)
-        event.listen(table, 'on_after_drop', canary.after_drop)
+        event.listen(table, 'after_drop', canary.after_drop)
 
         table.create(bind)
         assert canary.state is None
@@ -103,8 +103,8 @@ class DDLEventTest(TestBase):
         table, bind = self.table, self.bind
         canary = self.Canary(table, bind)
 
-        event.listen(table, 'on_before_drop', canary.before_drop)
-        event.listen(table, 'on_after_drop', canary.after_drop)
+        event.listen(table, 'before_drop', canary.before_drop)
+        event.listen(table, 'after_drop', canary.after_drop)
 
         table.create(bind)
         assert canary.state is None
@@ -115,10 +115,10 @@ class DDLEventTest(TestBase):
         table, bind = self.table, self.bind
         canary = self.Canary(table, bind)
 
-        event.listen(table, 'on_before_create', canary.before_create)
-        event.listen(table, 'on_after_create', canary.after_create)
-        event.listen(table, 'on_before_drop', canary.before_drop)
-        event.listen(table, 'on_after_drop', canary.after_drop)
+        event.listen(table, 'before_create', canary.before_create)
+        event.listen(table, 'after_create', canary.after_create)
+        event.listen(table, 'before_drop', canary.before_drop)
+        event.listen(table, 'after_drop', canary.after_drop)
 
         assert canary.state is None
         table.create(bind)
@@ -130,7 +130,7 @@ class DDLEventTest(TestBase):
     def test_table_create_before(self):
         metadata, bind = self.metadata, self.bind
         canary = self.Canary(metadata, bind)
-        event.listen(metadata, 'on_before_create', canary.before_create)
+        event.listen(metadata, 'before_create', canary.before_create)
 
         metadata.create_all(bind)
         assert canary.state == 'before-create'
@@ -140,7 +140,7 @@ class DDLEventTest(TestBase):
     def test_metadata_create_after(self):
         metadata, bind = self.metadata, self.bind
         canary = self.Canary(metadata, bind)
-        event.listen(metadata, 'on_after_create', canary.after_create)
+        event.listen(metadata, 'after_create', canary.after_create)
 
         canary.state = 'skipped'
         metadata.create_all(bind)
@@ -152,8 +152,8 @@ class DDLEventTest(TestBase):
         metadata, bind = self.metadata, self.bind
         canary = self.Canary(metadata, bind)
             
-        event.listen(metadata, 'on_before_create', canary.before_create)
-        event.listen(metadata, 'on_after_create', canary.after_create)
+        event.listen(metadata, 'before_create', canary.before_create)
+        event.listen(metadata, 'after_create', canary.after_create)
 
         metadata.create_all(bind)
         assert canary.state == 'after-create'
@@ -164,10 +164,10 @@ class DDLEventTest(TestBase):
         metadata, table, bind = self.metadata, self.table, self.bind
         table_canary = self.Canary(table, bind)
 
-        event.listen(table, 'on_before_create', table_canary.before_create)
+        event.listen(table, 'before_create', table_canary.before_create)
 
         metadata_canary = self.Canary(metadata, bind)
-        event.listen(metadata, 'on_before_create', metadata_canary.before_create)
+        event.listen(metadata, 'before_create', metadata_canary.before_create)
         self.table.create(self.bind)
         assert metadata_canary.state == None
 
@@ -196,10 +196,10 @@ class DDLExecutionTest(TestBase):
 
     def test_table_standalone(self):
         users, engine = self.users, self.engine
-        event.listen(users, 'on_before_create', DDL('mxyzptlk'))
-        event.listen(users, 'on_after_create', DDL('klptzyxm'))
-        event.listen(users, 'on_before_drop', DDL('xyzzy'))
-        event.listen(users, 'on_after_drop', DDL('fnord'))
+        event.listen(users, 'before_create', DDL('mxyzptlk'))
+        event.listen(users, 'after_create', DDL('klptzyxm'))
+        event.listen(users, 'before_drop', DDL('xyzzy'))
+        event.listen(users, 'after_drop', DDL('fnord'))
 
         users.create()
         strings = [str(x) for x in engine.mock]
@@ -218,10 +218,10 @@ class DDLExecutionTest(TestBase):
     def test_table_by_metadata(self):
         metadata, users, engine = self.metadata, self.users, self.engine
 
-        event.listen(users, 'on_before_create', DDL('mxyzptlk'))
-        event.listen(users, 'on_after_create', DDL('klptzyxm'))
-        event.listen(users, 'on_before_drop', DDL('xyzzy'))
-        event.listen(users, 'on_after_drop', DDL('fnord'))
+        event.listen(users, 'before_create', DDL('mxyzptlk'))
+        event.listen(users, 'after_create', DDL('klptzyxm'))
+        event.listen(users, 'before_drop', DDL('xyzzy'))
+        event.listen(users, 'after_drop', DDL('fnord'))
 
         metadata.create_all()
         strings = [str(x) for x in engine.mock]
@@ -263,10 +263,10 @@ class DDLExecutionTest(TestBase):
     def test_metadata(self):
         metadata, engine = self.metadata, self.engine
 
-        event.listen(metadata, 'on_before_create', DDL('mxyzptlk'))
-        event.listen(metadata, 'on_after_create', DDL('klptzyxm'))
-        event.listen(metadata, 'on_before_drop', DDL('xyzzy'))
-        event.listen(metadata, 'on_after_drop', DDL('fnord'))
+        event.listen(metadata, 'before_create', DDL('mxyzptlk'))
+        event.listen(metadata, 'after_create', DDL('klptzyxm'))
+        event.listen(metadata, 'before_drop', DDL('xyzzy'))
+        event.listen(metadata, 'after_drop', DDL('fnord'))
 
         metadata.create_all()
         strings = [str(x) for x in engine.mock]
@@ -317,13 +317,13 @@ class DDLExecutionTest(TestBase):
 
         event.listen(
             users,
-            'on_after_create',
+            'after_create',
             AddConstraint(constraint).execute_if(dialect='postgresql'),
         )
         
         event.listen(
             users,
-            'on_before_drop',
+            'before_drop',
             DropConstraint(constraint).execute_if(dialect='postgresql'),
         )
         
diff --git a/test/engine/test_execute.py b/test/engine/test_execute.py
index 945641ef1..90d2bc578 100644
--- a/test/engine/test_execute.py
+++ b/test/engine/test_execute.py
@@ -468,8 +468,8 @@ class EngineEventsTest(TestBase):
             engines.testing_engine(options=dict(implicit_returning=False,
                                    strategy='threadlocal'))
             ]:
-            event.listen(engine, 'on_before_execute', execute)
-            event.listen(engine, 'on_before_cursor_execute', cursor_execute)
+            event.listen(engine, 'before_execute', execute)
+            event.listen(engine, 'before_cursor_execute', cursor_execute)
             
             m = MetaData(engine)
             t1 = Table('t1', m, 
@@ -521,15 +521,15 @@ class EngineEventsTest(TestBase):
 
     def test_options(self):
         canary = []
-        def on_execute(conn, *args, **kw):
+        def execute(conn, *args, **kw):
             canary.append('execute')
             
-        def on_cursor_execute(conn, *args, **kw):
+        def cursor_execute(conn, *args, **kw):
             canary.append('cursor_execute')
             
         engine = engines.testing_engine()
-        event.listen(engine, 'on_before_execute', on_execute)
-        event.listen(engine, 'on_before_cursor_execute', on_cursor_execute)
+        event.listen(engine, 'before_execute', execute)
+        event.listen(engine, 'before_cursor_execute', cursor_execute)
         conn = engine.connect()
         c2 = conn.execution_options(foo='bar')
         eq_(c2._execution_options, {'foo':'bar'})
@@ -545,11 +545,11 @@ class EngineEventsTest(TestBase):
                 canary.append(name)
             return go
 
-        def on_execute(conn, clauseelement, multiparams, params):
+        def execute(conn, clauseelement, multiparams, params):
             canary.append('execute')
             return clauseelement, multiparams, params
             
-        def on_cursor_execute(conn, cursor, statement, 
+        def cursor_execute(conn, cursor, statement, 
                         parameters, context, executemany):
             canary.append('cursor_execute')
             return statement, parameters
@@ -558,11 +558,11 @@ class EngineEventsTest(TestBase):
         
         assert_raises(
             tsa.exc.ArgumentError,
-            event.listen, engine, "on_begin", tracker("on_begin"), retval=True
+            event.listen, engine, "begin", tracker("begin"), retval=True
         )
         
-        event.listen(engine, "on_before_execute", on_execute, retval=True)
-        event.listen(engine, "on_before_cursor_execute", on_cursor_execute, retval=True)
+        event.listen(engine, "before_execute", execute, retval=True)
+        event.listen(engine, "before_cursor_execute", cursor_execute, retval=True)
         engine.execute(select([1]))
         eq_(
             canary, ['execute', 'cursor_execute']
@@ -578,11 +578,11 @@ class EngineEventsTest(TestBase):
             return go
             
         engine = engines.testing_engine()
-        event.listen(engine, 'on_before_execute', tracker('execute'))
-        event.listen(engine, 'on_before_cursor_execute', tracker('cursor_execute'))
-        event.listen(engine, 'on_begin', tracker('begin'))
-        event.listen(engine, 'on_commit', tracker('commit'))
-        event.listen(engine, 'on_rollback', tracker('rollback'))
+        event.listen(engine, 'before_execute', tracker('execute'))
+        event.listen(engine, 'before_cursor_execute', tracker('cursor_execute'))
+        event.listen(engine, 'begin', tracker('begin'))
+        event.listen(engine, 'commit', tracker('commit'))
+        event.listen(engine, 'rollback', tracker('rollback'))
         
         conn = engine.connect()
         trans = conn.begin()
@@ -611,7 +611,7 @@ class EngineEventsTest(TestBase):
                     'rollback_savepoint', 'release_savepoint',
                     'rollback', 'begin_twophase', 
                        'prepare_twophase', 'commit_twophase']:
-            event.listen(engine, 'on_%s' % name, tracker(name))
+            event.listen(engine, '%s' % name, tracker(name))
 
         conn = engine.connect()
 
diff --git a/test/engine/test_pool.py b/test/engine/test_pool.py
index 392223d79..e9679fee4 100644
--- a/test/engine/test_pool.py
+++ b/test/engine/test_pool.py
@@ -196,37 +196,37 @@ class PoolEventsTest(PoolTestBase):
     def _first_connect_event_fixture(self):
         p = self._queuepool_fixture()
         canary = []
-        def on_first_connect(*arg, **kw):
+        def first_connect(*arg, **kw):
             canary.append('first_connect')
         
-        event.listen(p, 'on_first_connect', on_first_connect)
+        event.listen(p, 'first_connect', first_connect)
         
         return p, canary
 
     def _connect_event_fixture(self):
         p = self._queuepool_fixture()
         canary = []
-        def on_connect(*arg, **kw):
+        def connect(*arg, **kw):
             canary.append('connect')
-        event.listen(p, 'on_connect', on_connect)
+        event.listen(p, 'connect', connect)
         
         return p, canary
 
     def _checkout_event_fixture(self):
         p = self._queuepool_fixture()
         canary = []
-        def on_checkout(*arg, **kw):
+        def checkout(*arg, **kw):
             canary.append('checkout')
-        event.listen(p, 'on_checkout', on_checkout)
+        event.listen(p, 'checkout', checkout)
         
         return p, canary
 
     def _checkin_event_fixture(self):
         p = self._queuepool_fixture()
         canary = []
-        def on_checkin(*arg, **kw):
+        def checkin(*arg, **kw):
             canary.append('checkin')
-        event.listen(p, 'on_checkin', on_checkin)
+        event.listen(p, 'checkin', checkin)
         
         return p, canary
         
@@ -361,10 +361,10 @@ class PoolEventsTest(PoolTestBase):
             canary.append("listen_four")
             
         engine = create_engine(testing.db.url)
-        event.listen(pool.Pool, 'on_connect', listen_one)
-        event.listen(engine.pool, 'on_connect', listen_two)
-        event.listen(engine, 'on_connect', listen_three)
-        event.listen(engine.__class__, 'on_connect', listen_four)
+        event.listen(pool.Pool, 'connect', listen_one)
+        event.listen(engine.pool, 'connect', listen_two)
+        event.listen(engine, 'connect', listen_three)
+        event.listen(engine.__class__, 'connect', listen_four)
 
         engine.execute(select([1])).close()
         eq_(
@@ -382,19 +382,19 @@ class PoolEventsTest(PoolTestBase):
         def listen_three(*args):
             canary.append("listen_three")
         
-        event.listen(pool.Pool, 'on_connect', listen_one)
-        event.listen(pool.QueuePool, 'on_connect', listen_two)
-        event.listen(pool.SingletonThreadPool, 'on_connect', listen_three)
+        event.listen(pool.Pool, 'connect', listen_one)
+        event.listen(pool.QueuePool, 'connect', listen_two)
+        event.listen(pool.SingletonThreadPool, 'connect', listen_three)
         
         p1 = pool.QueuePool(creator=MockDBAPI().connect)
         p2 = pool.SingletonThreadPool(creator=MockDBAPI().connect)
         
-        assert listen_one in p1.dispatch.on_connect
-        assert listen_two in p1.dispatch.on_connect
-        assert listen_three not in p1.dispatch.on_connect
-        assert listen_one in p2.dispatch.on_connect
-        assert listen_two not in p2.dispatch.on_connect
-        assert listen_three in p2.dispatch.on_connect
+        assert listen_one in p1.dispatch.connect
+        assert listen_two in p1.dispatch.connect
+        assert listen_three not in p1.dispatch.connect
+        assert listen_one in p2.dispatch.connect
+        assert listen_two not in p2.dispatch.connect
+        assert listen_three in p2.dispatch.connect
 
         p1.connect()
         eq_(canary, ["listen_one", "listen_two"])
@@ -475,10 +475,10 @@ class DeprecatedPoolListenerTest(PoolTestBase):
 
         def assert_listeners(p, total, conn, fconn, cout, cin):
             for instance in (p, p.recreate()):
-                self.assert_(len(instance.dispatch.on_connect) == conn)
-                self.assert_(len(instance.dispatch.on_first_connect) == fconn)
-                self.assert_(len(instance.dispatch.on_checkout) == cout)
-                self.assert_(len(instance.dispatch.on_checkin) == cin)
+                self.assert_(len(instance.dispatch.connect) == conn)
+                self.assert_(len(instance.dispatch.first_connect) == fconn)
+                self.assert_(len(instance.dispatch.checkout) == cout)
+                self.assert_(len(instance.dispatch.checkin) == cin)
 
         p = self._queuepool_fixture()
         assert_listeners(p, 0, 0, 0, 0, 0)
@@ -601,9 +601,9 @@ class DeprecatedPoolListenerTest(PoolTestBase):
 
             def assert_listeners(p, total, conn, cout, cin):
                 for instance in (p, p.recreate()):
-                    eq_(len(instance.dispatch.on_connect), conn)
-                    eq_(len(instance.dispatch.on_checkout), cout)
-                    eq_(len(instance.dispatch.on_checkin), cin)
+                    eq_(len(instance.dispatch.connect), conn)
+                    eq_(len(instance.dispatch.checkout), cout)
+                    eq_(len(instance.dispatch.checkin), cin)
 
             p = self._queuepool_fixture()
             assert_listeners(p, 0, 0, 0, 0)
diff --git a/test/ext/test_mutable.py b/test/ext/test_mutable.py
index 8a51bd3fa..3e7a23b8d 100644
--- a/test/ext/test_mutable.py
+++ b/test/ext/test_mutable.py
@@ -35,11 +35,11 @@ class _MutableDictTestBase(object):
             
             def __setitem__(self, key, value):
                 dict.__setitem__(self, key, value)
-                self.on_change()
+                self.change()
     
             def __delitem__(self, key):
                 dict.__delitem__(self, key)
-                self.on_change()
+                self.change()
         return MutationDict
     
     @testing.resolve_artifact_names
@@ -199,7 +199,7 @@ class MutableCompositesTest(_base.MappedTest):
 
             def __setattr__(self, key, value):
                 object.__setattr__(self, key, value)
-                self.on_change()
+                self.change()
         
             def __composite_values__(self):
                 return self.x, self.y
diff --git a/test/lib/engines.py b/test/lib/engines.py
index a57795f15..60272839b 100644
--- a/test/lib/engines.py
+++ b/test/lib/engines.py
@@ -132,9 +132,9 @@ def testing_engine(url=None, options=None):
     options = options or config.db_opts
 
     engine = create_engine(url, **options)
-    event.listen(engine, 'on_after_execute', asserter.execute)
-    event.listen(engine, 'on_after_cursor_execute', asserter.cursor_execute)
-    event.listen(engine.pool, 'on_checkout', testing_reaper.checkout)
+    event.listen(engine, 'after_execute', asserter.execute)
+    event.listen(engine, 'after_cursor_execute', asserter.cursor_execute)
+    event.listen(engine.pool, 'checkout', testing_reaper.checkout)
     
     # may want to call this, results
     # in first-connect initializers
diff --git a/test/orm/test_attributes.py b/test/orm/test_attributes.py
index 30156bbb7..e82e9e854 100644
--- a/test/orm/test_attributes.py
+++ b/test/orm/test_attributes.py
@@ -1627,7 +1627,7 @@ class ListenerTest(_base.ORMTest):
         class Bar(object):
             pass
             
-        def on_append(state, child, initiator):
+        def append(state, child, initiator):
             b2 = Bar()
             b2.data = b1.data + " appended"
             return b2
@@ -1642,9 +1642,9 @@ class ListenerTest(_base.ORMTest):
         attributes.register_attribute(Foo, 'barset', typecallable=set, uselist=True, useobject=True)
         attributes.register_attribute(Bar, 'data', uselist=False, useobject=False)
         
-        event.listen(Foo.data, 'on_set', on_set, retval=True)
-        event.listen(Foo.barlist, 'on_append', on_append, retval=True)
-        event.listen(Foo.barset, 'on_append', on_append, retval=True)
+        event.listen(Foo.data, 'set', on_set, retval=True)
+        event.listen(Foo.barlist, 'append', append, retval=True)
+        event.listen(Foo.barset, 'append', append, retval=True)
         
         f1 = Foo()
         f1.data = "some data"
@@ -1694,11 +1694,11 @@ class ListenerTest(_base.ORMTest):
         def attr_c():
             attributes.register_attribute(classes[2], 'attrib', uselist=False, useobject=False)
         
-        def on_set(state, value, oldvalue, initiator):
+        def set(state, value, oldvalue, initiator):
             canary.append(value)
             
         def events_a():
-            event.listen(classes[0].attrib, 'on_set', on_set, propagate=True)
+            event.listen(classes[0].attrib, 'set', set, propagate=True)
         
         def teardown():
             classes[:] = [None, None, None]
diff --git a/test/orm/test_defaults.py b/test/orm/test_defaults.py
index 278eaf0b6..f7e39a4fb 100644
--- a/test/orm/test_defaults.py
+++ b/test/orm/test_defaults.py
@@ -46,9 +46,9 @@ class TriggerDefaultsTest(_base.MappedTest):
                                 bind.engine.name not in ('oracle', 'mssql', 'sqlite')
                 ),
             ):
-            event.listen(dt, 'on_after_create', ins)
+            event.listen(dt, 'after_create', ins)
         
-        event.listen(dt, 'on_before_drop', sa.DDL("DROP TRIGGER dt_ins"))
+        event.listen(dt, 'before_drop', sa.DDL("DROP TRIGGER dt_ins"))
 
         for up in (
             sa.DDL("CREATE TRIGGER dt_up AFTER UPDATE ON dt "
@@ -71,9 +71,9 @@ class TriggerDefaultsTest(_base.MappedTest):
                                 bind.engine.name not in ('oracle', 'mssql', 'sqlite')
                     ),
             ):
-            event.listen(dt, 'on_after_create', up)
+            event.listen(dt, 'after_create', up)
 
-        event.listen(dt, 'on_before_drop', sa.DDL("DROP TRIGGER dt_up"))
+        event.listen(dt, 'before_drop', sa.DDL("DROP TRIGGER dt_up"))
 
 
     @classmethod
diff --git a/test/orm/test_instrumentation.py b/test/orm/test_instrumentation.py
index d624772d0..3d3c96c6a 100644
--- a/test/orm/test_instrumentation.py
+++ b/test/orm/test_instrumentation.py
@@ -43,9 +43,9 @@ class InitTest(_base.ORMTest):
         instrumentation.register_class(cls)
         ne_(cls.__init__, original_init)
         manager = instrumentation.manager_of_class(cls)
-        def on_init(state, args, kwargs):
-            canary.append((cls, 'on_init', state.class_))
-        event.listen(manager, 'on_init', on_init, raw=True)
+        def init(state, args, kwargs):
+            canary.append((cls, 'init', state.class_))
+        event.listen(manager, 'init', init, raw=True)
 
     def test_ai(self):
         inits = []
@@ -64,7 +64,7 @@ class InitTest(_base.ORMTest):
         self.register(A, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A)])
+        eq_(inits, [(A, 'init', A)])
 
     def test_Ai(self):
         inits = []
@@ -75,7 +75,7 @@ class InitTest(_base.ORMTest):
         self.register(A, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A), (A, '__init__')])
+        eq_(inits, [(A, 'init', A), (A, '__init__')])
 
     def test_ai_B(self):
         inits = []
@@ -93,7 +93,7 @@ class InitTest(_base.ORMTest):
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, 'on_init', B), (A, '__init__')])
+        eq_(inits, [(B, 'init', B), (A, '__init__')])
 
     def test_ai_Bi(self):
         inits = []
@@ -114,7 +114,7 @@ class InitTest(_base.ORMTest):
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, 'on_init', B), (B, '__init__'), (A, '__init__')])
+        eq_(inits, [(B, 'init', B), (B, '__init__'), (A, '__init__')])
 
     def test_Ai_bi(self):
         inits = []
@@ -130,12 +130,12 @@ class InitTest(_base.ORMTest):
                 super(B, self).__init__()
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A), (A, '__init__')])
+        eq_(inits, [(A, 'init', A), (A, '__init__')])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, '__init__'), (A, 'on_init', B), (A, '__init__')])
+        eq_(inits, [(B, '__init__'), (A, 'init', B), (A, '__init__')])
 
     def test_Ai_Bi(self):
         inits = []
@@ -152,12 +152,12 @@ class InitTest(_base.ORMTest):
         self.register(B, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A), (A, '__init__')])
+        eq_(inits, [(A, 'init', A), (A, '__init__')])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, 'on_init', B), (B, '__init__'), (A, '__init__')])
+        eq_(inits, [(B, 'init', B), (B, '__init__'), (A, '__init__')])
 
     def test_Ai_B(self):
         inits = []
@@ -171,12 +171,12 @@ class InitTest(_base.ORMTest):
         self.register(B, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A), (A, '__init__')])
+        eq_(inits, [(A, 'init', A), (A, '__init__')])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, 'on_init', B), (A, '__init__')])
+        eq_(inits, [(B, 'init', B), (A, '__init__')])
 
     def test_Ai_Bi_Ci(self):
         inits = []
@@ -199,16 +199,16 @@ class InitTest(_base.ORMTest):
         self.register(C, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A), (A, '__init__')])
+        eq_(inits, [(A, 'init', A), (A, '__init__')])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, 'on_init', B), (B, '__init__'), (A, '__init__')])
+        eq_(inits, [(B, 'init', B), (B, '__init__'), (A, '__init__')])
 
         del inits[:]
         obj = C()
-        eq_(inits, [(C, 'on_init', C), (C, '__init__'), (B, '__init__'),
+        eq_(inits, [(C, 'init', C), (C, '__init__'), (B, '__init__'),
                    (A, '__init__')])
 
     def test_Ai_bi_Ci(self):
@@ -231,16 +231,16 @@ class InitTest(_base.ORMTest):
         self.register(C, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A), (A, '__init__')])
+        eq_(inits, [(A, 'init', A), (A, '__init__')])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, '__init__'), (A, 'on_init', B), (A, '__init__')])
+        eq_(inits, [(B, '__init__'), (A, 'init', B), (A, '__init__')])
 
         del inits[:]
         obj = C()
-        eq_(inits, [(C, 'on_init', C), (C, '__init__'),  (B, '__init__'),
+        eq_(inits, [(C, 'init', C), (C, '__init__'),  (B, '__init__'),
                    (A, '__init__')])
 
     def test_Ai_b_Ci(self):
@@ -260,16 +260,16 @@ class InitTest(_base.ORMTest):
         self.register(C, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A), (A, '__init__')])
+        eq_(inits, [(A, 'init', A), (A, '__init__')])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(A, 'on_init', B), (A, '__init__')])
+        eq_(inits, [(A, 'init', B), (A, '__init__')])
 
         del inits[:]
         obj = C()
-        eq_(inits, [(C, 'on_init', C), (C, '__init__'), (A, '__init__')])
+        eq_(inits, [(C, 'init', C), (C, '__init__'), (A, '__init__')])
 
     def test_Ai_B_Ci(self):
         inits = []
@@ -289,16 +289,16 @@ class InitTest(_base.ORMTest):
         self.register(C, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A), (A, '__init__')])
+        eq_(inits, [(A, 'init', A), (A, '__init__')])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, 'on_init', B), (A, '__init__')])
+        eq_(inits, [(B, 'init', B), (A, '__init__')])
 
         del inits[:]
         obj = C()
-        eq_(inits, [(C, 'on_init', C), (C, '__init__'), (A, '__init__')])
+        eq_(inits, [(C, 'init', C), (C, '__init__'), (A, '__init__')])
 
     def test_Ai_B_C(self):
         inits = []
@@ -315,16 +315,16 @@ class InitTest(_base.ORMTest):
         self.register(C, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A), (A, '__init__')])
+        eq_(inits, [(A, 'init', A), (A, '__init__')])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, 'on_init', B), (A, '__init__')])
+        eq_(inits, [(B, 'init', B), (A, '__init__')])
 
         del inits[:]
         obj = C()
-        eq_(inits, [(C, 'on_init', C), (A, '__init__')])
+        eq_(inits, [(C, 'init', C), (A, '__init__')])
 
     def test_A_Bi_C(self):
         inits = []
@@ -341,16 +341,16 @@ class InitTest(_base.ORMTest):
         self.register(C, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A)])
+        eq_(inits, [(A, 'init', A)])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, 'on_init', B), (B, '__init__')])
+        eq_(inits, [(B, 'init', B), (B, '__init__')])
 
         del inits[:]
         obj = C()
-        eq_(inits, [(C, 'on_init', C), (B, '__init__')])
+        eq_(inits, [(C, 'init', C), (B, '__init__')])
 
     def test_A_B_Ci(self):
         inits = []
@@ -367,16 +367,16 @@ class InitTest(_base.ORMTest):
         self.register(C, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A)])
+        eq_(inits, [(A, 'init', A)])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, 'on_init', B)])
+        eq_(inits, [(B, 'init', B)])
 
         del inits[:]
         obj = C()
-        eq_(inits, [(C, 'on_init', C), (C, '__init__')])
+        eq_(inits, [(C, 'init', C), (C, '__init__')])
 
     def test_A_B_C(self):
         inits = []
@@ -391,16 +391,16 @@ class InitTest(_base.ORMTest):
         self.register(C, inits)
 
         obj = A()
-        eq_(inits, [(A, 'on_init', A)])
+        eq_(inits, [(A, 'init', A)])
 
         del inits[:]
 
         obj = B()
-        eq_(inits, [(B, 'on_init', B)])
+        eq_(inits, [(B, 'init', B)])
 
         del inits[:]
         obj = C()
-        eq_(inits, [(C, 'on_init', C)])
+        eq_(inits, [(C, 'init', C)])
 
     def test_defaulted_init(self):
         class X(object):
@@ -537,7 +537,7 @@ class InstrumentationCollisionTest(_base.ORMTest):
         assert_raises_message(TypeError, "multiple instrumentation implementations", instrumentation.register_class, B1)
 
 class OnLoadTest(_base.ORMTest):
-    """Check that Events.on_load is not hit in regular attributes operations."""
+    """Check that Events.load is not hit in regular attributes operations."""
 
     def test_basic(self):
         import pickle
@@ -551,7 +551,7 @@ class OnLoadTest(_base.ORMTest):
         try:
             instrumentation.register_class(A)
             manager = instrumentation.manager_of_class(A)
-            event.listen(manager, 'on_load', canary)
+            event.listen(manager, 'load', canary)
 
             a = A()
             p_a = pickle.dumps(a)
diff --git a/test/orm/test_mapper.py b/test/orm/test_mapper.py
index 11a66c17f..ad0662887 100644
--- a/test/orm/test_mapper.py
+++ b/test/orm/test_mapper.py
@@ -2271,35 +2271,35 @@ class MapperEventsTest(_fixtures.FixtureTest):
         mapper(A, users)
         mapper(B, addresses, inherits=A)
         
-        def on_init_a(target, args, kwargs):
-            canary.append(('on_init_a', target))
+        def init_a(target, args, kwargs):
+            canary.append(('init_a', target))
             
-        def on_init_b(target, args, kwargs):
-            canary.append(('on_init_b', target))
+        def init_b(target, args, kwargs):
+            canary.append(('init_b', target))
 
-        def on_init_c(target, args, kwargs):
-            canary.append(('on_init_c', target))
+        def init_c(target, args, kwargs):
+            canary.append(('init_c', target))
 
-        def on_init_d(target, args, kwargs):
-            canary.append(('on_init_d', target))
+        def init_d(target, args, kwargs):
+            canary.append(('init_d', target))
 
-        def on_init_e(target, args, kwargs):
-            canary.append(('on_init_e', target))
+        def init_e(target, args, kwargs):
+            canary.append(('init_e', target))
         
-        event.listen(mapper, 'on_init', on_init_a)
-        event.listen(Mapper, 'on_init', on_init_b)
-        event.listen(class_mapper(A), 'on_init', on_init_c)
-        event.listen(A, 'on_init', on_init_d)
-        event.listen(A, 'on_init', on_init_e, propagate=True)
+        event.listen(mapper, 'init', init_a)
+        event.listen(Mapper, 'init', init_b)
+        event.listen(class_mapper(A), 'init', init_c)
+        event.listen(A, 'init', init_d)
+        event.listen(A, 'init', init_e, propagate=True)
         
         a = A()
-        eq_(canary, [('on_init_a', a),('on_init_b', a),
-                        ('on_init_c', a),('on_init_d', a),('on_init_e', a)])
+        eq_(canary, [('init_a', a),('init_b', a),
+                        ('init_c', a),('init_d', a),('init_e', a)])
         
         # test propagate flag
         canary[:] = []
         b = B()
-        eq_(canary, [('on_init_a', b), ('on_init_b', b),('on_init_e', b)])
+        eq_(canary, [('init_a', b), ('init_b', b),('init_e', b)])
     
     def teardown(self):
         # TODO: need to get remove() functionality
@@ -2316,21 +2316,21 @@ class MapperEventsTest(_fixtures.FixtureTest):
             return go
             
         for meth in [
-            'on_init',
-            'on_init_failure',
-            'on_translate_row',
-            'on_create_instance',
-            'on_append_result',
-            'on_populate_instance',
-            'on_load',
-            'on_refresh',
-            'on_expire',
-            'on_before_insert',
-            'on_after_insert',
-            'on_before_update',
-            'on_after_update',
-            'on_before_delete',
-            'on_after_delete'
+            'init',
+            'init_failure',
+            'translate_row',
+            'create_instance',
+            'append_result',
+            'populate_instance',
+            'load',
+            'refresh',
+            'expire',
+            'before_insert',
+            'after_insert',
+            'before_update',
+            'after_update',
+            'before_delete',
+            'after_delete'
         ]:
             event.listen(mapper, meth, evt(meth), **kw)
         return canary
@@ -2354,12 +2354,12 @@ class MapperEventsTest(_fixtures.FixtureTest):
         sess.delete(u)
         sess.flush()
         eq_(canary,
-            ['on_init', 'on_before_insert',
-             'on_after_insert', 'on_expire', 'on_translate_row', 'on_populate_instance',
-             'on_refresh',
-             'on_append_result', 'on_translate_row', 'on_create_instance',
-             'on_populate_instance', 'on_load', 'on_append_result',
-             'on_before_update', 'on_after_update', 'on_before_delete', 'on_after_delete'])
+            ['init', 'before_insert',
+             'after_insert', 'expire', 'translate_row', 'populate_instance',
+             'refresh',
+             'append_result', 'translate_row', 'create_instance',
+             'populate_instance', 'load', 'append_result',
+             'before_update', 'after_update', 'before_delete', 'after_delete'])
 
     @testing.resolve_artifact_names
     def test_inheritance(self):
@@ -2384,24 +2384,24 @@ class MapperEventsTest(_fixtures.FixtureTest):
         sess.flush()
         sess.delete(am)
         sess.flush()
-        eq_(canary1, ['on_init', 'on_before_insert', 'on_after_insert',
-            'on_translate_row', 'on_populate_instance','on_refresh',
-            'on_append_result', 'on_translate_row', 'on_create_instance'
-            , 'on_populate_instance', 'on_load', 'on_append_result',
-            'on_before_update', 'on_after_update', 'on_before_delete',
-            'on_after_delete'])
+        eq_(canary1, ['init', 'before_insert', 'after_insert',
+            'translate_row', 'populate_instance','refresh',
+            'append_result', 'translate_row', 'create_instance'
+            , 'populate_instance', 'load', 'append_result',
+            'before_update', 'after_update', 'before_delete',
+            'after_delete'])
         eq_(canary2, [])
-        eq_(canary3, ['on_init', 'on_before_insert', 'on_after_insert',
-            'on_translate_row', 'on_populate_instance','on_refresh',
-            'on_append_result', 'on_translate_row', 'on_create_instance'
-            , 'on_populate_instance', 'on_load', 'on_append_result',
-            'on_before_update', 'on_after_update', 'on_before_delete',
-            'on_after_delete'])
+        eq_(canary3, ['init', 'before_insert', 'after_insert',
+            'translate_row', 'populate_instance','refresh',
+            'append_result', 'translate_row', 'create_instance'
+            , 'populate_instance', 'load', 'append_result',
+            'before_update', 'after_update', 'before_delete',
+            'after_delete'])
 
     @testing.resolve_artifact_names
     def test_before_after_only_collection(self):
-        """on_before_update is called on parent for collection modifications,
-        on_after_update is called even if no columns were updated.
+        """before_update is called on parent for collection modifications,
+        after_update is called even if no columns were updated.
         
         """
 
@@ -2419,18 +2419,18 @@ class MapperEventsTest(_fixtures.FixtureTest):
         sess.add(k1)
         sess.flush()
         eq_(canary1,
-            ['on_init', 
-            'on_before_insert', 'on_after_insert'])
+            ['init', 
+            'before_insert', 'after_insert'])
         eq_(canary2,
-            ['on_init', 
-            'on_before_insert', 'on_after_insert'])
+            ['init', 
+            'before_insert', 'after_insert'])
 
         canary1[:]= []
         canary2[:]= []
 
         i1.keywords.append(k1)
         sess.flush()
-        eq_(canary1, ['on_before_update', 'on_after_update'])
+        eq_(canary1, ['before_update', 'after_update'])
         eq_(canary2, [])
 
         
@@ -2442,7 +2442,7 @@ class MapperEventsTest(_fixtures.FixtureTest):
             return u
             
         mapper(User, users)
-        event.listen(User, 'on_create_instance', create_instance, retval=True)
+        event.listen(User, 'create_instance', create_instance, retval=True)
         sess = create_session()
         u1 = User()
         u1.name = 'ed'
@@ -2455,10 +2455,10 @@ class MapperEventsTest(_fixtures.FixtureTest):
     @testing.resolve_artifact_names
     def test_instrument_event(self):
         canary = []
-        def on_instrument_class(mapper, cls):
+        def instrument_class(mapper, cls):
             canary.append(cls)
             
-        event.listen(Mapper, 'on_instrument_class', on_instrument_class)
+        event.listen(Mapper, 'instrument_class', instrument_class)
         
         mapper(User, users)
         eq_(canary, [User])
diff --git a/test/orm/test_merge.py b/test/orm/test_merge.py
index 5329fb71c..d190db96f 100644
--- a/test/orm/test_merge.py
+++ b/test/orm/test_merge.py
@@ -18,13 +18,13 @@ class MergeTest(_fixtures.FixtureTest):
 
     run_inserts = None
 
-    def on_load_tracker(self, cls, canary=None):
+    def load_tracker(self, cls, canary=None):
         if canary is None:
             def canary(instance):
                 canary.called += 1
             canary.called = 0
 
-        event.listen(cls, 'on_load', canary)
+        event.listen(cls, 'load', canary)
 
         return canary
 
@@ -32,12 +32,12 @@ class MergeTest(_fixtures.FixtureTest):
     def test_transient_to_pending(self):
         mapper(User, users)
         sess = create_session()
-        on_load = self.on_load_tracker(User)
+        load = self.load_tracker(User)
 
         u = User(id=7, name='fred')
-        eq_(on_load.called, 0)
+        eq_(load.called, 0)
         u2 = sess.merge(u)
-        eq_(on_load.called, 1)
+        eq_(load.called, 1)
         assert u2 in sess
         eq_(u2, User(id=7, name='fred'))
         sess.flush()
@@ -60,18 +60,18 @@ class MergeTest(_fixtures.FixtureTest):
             'addresses': relationship(Address, backref='user',
                                   collection_class=OrderedSet)})
         mapper(Address, addresses)
-        on_load = self.on_load_tracker(User)
-        self.on_load_tracker(Address, on_load)
+        load = self.load_tracker(User)
+        self.load_tracker(Address, load)
 
         u = User(id=7, name='fred', addresses=OrderedSet([
             Address(id=1, email_address='fred1'),
             Address(id=2, email_address='fred2'),
             ]))
-        eq_(on_load.called, 0)
+        eq_(load.called, 0)
 
         sess = create_session()
         sess.merge(u)
-        eq_(on_load.called, 3)
+        eq_(load.called, 3)
 
         merged_users = [e for e in sess if isinstance(e, User)]
         eq_(len(merged_users), 1)
@@ -90,7 +90,7 @@ class MergeTest(_fixtures.FixtureTest):
     @testing.resolve_artifact_names
     def test_transient_to_persistent(self):
         mapper(User, users)
-        on_load = self.on_load_tracker(User)
+        load = self.load_tracker(User)
 
         sess = create_session()
         u = User(id=7, name='fred')
@@ -98,17 +98,17 @@ class MergeTest(_fixtures.FixtureTest):
         sess.flush()
         sess.expunge_all()
 
-        eq_(on_load.called, 0)
+        eq_(load.called, 0)
 
         _u2 = u2 = User(id=7, name='fred jones')
-        eq_(on_load.called, 0)
+        eq_(load.called, 0)
         u2 = sess.merge(u2)
         assert u2 is not _u2
-        eq_(on_load.called, 1)
+        eq_(load.called, 1)
         sess.flush()
         sess.expunge_all()
         eq_(sess.query(User).first(), User(id=7, name='fred jones'))
-        eq_(on_load.called, 2)
+        eq_(load.called, 2)
 
     @testing.resolve_artifact_names
     def test_transient_to_persistent_collection(self):
@@ -121,8 +121,8 @@ class MergeTest(_fixtures.FixtureTest):
         })
         mapper(Address, addresses)
 
-        on_load = self.on_load_tracker(User)
-        self.on_load_tracker(Address, on_load)
+        load = self.load_tracker(User)
+        self.load_tracker(Address, load)
 
         u = User(id=7, name='fred', addresses=OrderedSet([
             Address(id=1, email_address='fred1'),
@@ -133,7 +133,7 @@ class MergeTest(_fixtures.FixtureTest):
         sess.flush()
         sess.expunge_all()
 
-        eq_(on_load.called, 0)
+        eq_(load.called, 0)
 
         u = User(id=7, name='fred', addresses=OrderedSet([
             Address(id=3, email_address='fred3'),
@@ -146,7 +146,7 @@ class MergeTest(_fixtures.FixtureTest):
         # 2.,3. merges Address ids 3 & 4, saves into session.
         # 4.,5. loads pre-existing elements in "addresses" collection,
         # marks as deleted, Address ids 1 and 2.
-        eq_(on_load.called, 5)
+        eq_(load.called, 5)
 
         eq_(u,
             User(id=7, name='fred', addresses=OrderedSet([
@@ -171,8 +171,8 @@ class MergeTest(_fixtures.FixtureTest):
                                  order_by=addresses.c.id,
                                  collection_class=OrderedSet)})
         mapper(Address, addresses)
-        on_load = self.on_load_tracker(User)
-        self.on_load_tracker(Address, on_load)
+        load = self.load_tracker(User)
+        self.load_tracker(Address, load)
 
         a = Address(id=1, email_address='fred1')
         u = User(id=7, name='fred', addresses=OrderedSet([
@@ -188,9 +188,9 @@ class MergeTest(_fixtures.FixtureTest):
         u.addresses.add(Address(id=3, email_address='fred3'))
         u.addresses.remove(a)
 
-        eq_(on_load.called, 0)
+        eq_(load.called, 0)
         u = sess.merge(u)
-        eq_(on_load.called, 4)
+        eq_(load.called, 4)
         sess.flush()
         sess.expunge_all()
 
@@ -207,8 +207,8 @@ class MergeTest(_fixtures.FixtureTest):
             'addresses':relationship(mapper(Address, addresses),
                                  cascade="all", backref="user")
         })
-        on_load = self.on_load_tracker(User)
-        self.on_load_tracker(Address, on_load)
+        load = self.load_tracker(User)
+        self.load_tracker(Address, load)
         sess = create_session()
 
         u = User(id=7, name='fred')
@@ -218,7 +218,7 @@ class MergeTest(_fixtures.FixtureTest):
         u.addresses.append(a2)
 
         u2 = sess.merge(u)
-        eq_(on_load.called, 3)
+        eq_(load.called, 3)
 
         eq_(u,
             User(id=7, name='fred', addresses=[
@@ -236,7 +236,7 @@ class MergeTest(_fixtures.FixtureTest):
         eq_(u2, User(id=7, name='fred', addresses=[
             Address(email_address='foo@bar.com'),
             Address(email_address='hoho@bar.com')]))
-        eq_(on_load.called, 6)
+        eq_(load.called, 6)
 
     @testing.resolve_artifact_names
     def test_merge_empty_attributes(self):
@@ -324,8 +324,8 @@ class MergeTest(_fixtures.FixtureTest):
         mapper(User, users, properties={
             'addresses':relationship(mapper(Address, addresses), backref='user')
         })
-        on_load = self.on_load_tracker(User)
-        self.on_load_tracker(Address, on_load)
+        load = self.load_tracker(User)
+        self.load_tracker(Address, load)
 
         sess = create_session()
 
@@ -348,12 +348,12 @@ class MergeTest(_fixtures.FixtureTest):
         u.name = 'fred2'
         u.addresses[1].email_address = 'hoho@lalala.com'
 
-        eq_(on_load.called, 3)
+        eq_(load.called, 3)
 
         # new session, merge modified data into session
         sess3 = create_session()
         u3 = sess3.merge(u)
-        eq_(on_load.called, 6)
+        eq_(load.called, 6)
 
         # ensure local changes are pending
         eq_(u3, User(id=7, name='fred2', addresses=[
@@ -369,7 +369,7 @@ class MergeTest(_fixtures.FixtureTest):
         eq_(u, User(id=7, name='fred2', addresses=[
             Address(email_address='foo@bar.com'),
             Address(email_address='hoho@lalala.com')]))
-        eq_(on_load.called, 9)
+        eq_(load.called, 9)
 
         # merge persistent object into another session
         sess4 = create_session()
@@ -381,7 +381,7 @@ class MergeTest(_fixtures.FixtureTest):
             sess4.flush()
         # no changes; therefore flush should do nothing
         self.assert_sql_count(testing.db, go, 0)
-        eq_(on_load.called, 12)
+        eq_(load.called, 12)
 
         # test with "dontload" merge
         sess5 = create_session()
@@ -395,7 +395,7 @@ class MergeTest(_fixtures.FixtureTest):
         # but also, load=False wipes out any difference in committed state,
         # so no flush at all
         self.assert_sql_count(testing.db, go, 0)
-        eq_(on_load.called, 15)
+        eq_(load.called, 15)
 
         sess4 = create_session()
         u = sess4.merge(u, load=False)
@@ -405,13 +405,13 @@ class MergeTest(_fixtures.FixtureTest):
             sess4.flush()
         # afafds change flushes
         self.assert_sql_count(testing.db, go, 1)
-        eq_(on_load.called, 18)
+        eq_(load.called, 18)
 
         sess5 = create_session()
         u2 = sess5.query(User).get(u.id)
         eq_(u2.name, 'fred2')
         eq_(u2.addresses[1].email_address, 'afafds')
-        eq_(on_load.called, 21)
+        eq_(load.called, 21)
 
     @testing.resolve_artifact_names
     def test_no_relationship_cascade(self):
@@ -454,8 +454,8 @@ class MergeTest(_fixtures.FixtureTest):
         mapper(User, users, properties={
             'addresses':relationship(mapper(Address, addresses))})
 
-        on_load = self.on_load_tracker(User)
-        self.on_load_tracker(Address, on_load)
+        load = self.load_tracker(User)
+        self.load_tracker(Address, load)
 
         sess = create_session()
         u = User(name='fred')
@@ -466,24 +466,24 @@ class MergeTest(_fixtures.FixtureTest):
         sess.add(u)
         sess.flush()
 
-        eq_(on_load.called, 0)
+        eq_(load.called, 0)
 
         sess2 = create_session()
         u2 = sess2.query(User).get(u.id)
-        eq_(on_load.called, 1)
+        eq_(load.called, 1)
 
         u.addresses[1].email_address = 'addr 2 modified'
         sess2.merge(u)
         eq_(u2.addresses[1].email_address, 'addr 2 modified')
-        eq_(on_load.called, 3)
+        eq_(load.called, 3)
 
         sess3 = create_session()
         u3 = sess3.query(User).get(u.id)
-        eq_(on_load.called, 4)
+        eq_(load.called, 4)
 
         u.name = 'also fred'
         sess3.merge(u)
-        eq_(on_load.called, 6)
+        eq_(load.called, 6)
         eq_(u3.name, 'also fred')
 
     @testing.resolve_artifact_names
@@ -527,8 +527,8 @@ class MergeTest(_fixtures.FixtureTest):
         mapper(Order, orders, properties={
             'items':relationship(mapper(Item, items), secondary=order_items)})
 
-        on_load = self.on_load_tracker(Order)
-        self.on_load_tracker(Item, on_load)
+        load = self.load_tracker(Order)
+        self.load_tracker(Item, load)
 
         sess = create_session()
 
@@ -546,24 +546,24 @@ class MergeTest(_fixtures.FixtureTest):
         sess.add(o)
         sess.flush()
 
-        eq_(on_load.called, 0)
+        eq_(load.called, 0)
 
         sess2 = create_session()
         o2 = sess2.query(Order).get(o.id)
-        eq_(on_load.called, 1)
+        eq_(load.called, 1)
 
         o.items[1].description = 'item 2 modified'
         sess2.merge(o)
         eq_(o2.items[1].description, 'item 2 modified')
-        eq_(on_load.called,  3)
+        eq_(load.called,  3)
 
         sess3 = create_session()
         o3 = sess3.query(Order).get(o.id)
-        eq_( on_load.called, 4)
+        eq_( load.called, 4)
 
         o.description = 'desc modified'
         sess3.merge(o)
-        eq_(on_load.called, 6)
+        eq_(load.called, 6)
         eq_(o3.description, 'desc modified')
 
     @testing.resolve_artifact_names
@@ -572,8 +572,8 @@ class MergeTest(_fixtures.FixtureTest):
         mapper(User, users, properties={
             'address':relationship(mapper(Address, addresses),uselist = False)
         })
-        on_load = self.on_load_tracker(User)
-        self.on_load_tracker(Address, on_load)
+        load = self.load_tracker(User)
+        self.load_tracker(Address, load)
         sess = create_session()
 
         u = User()
@@ -586,17 +586,17 @@ class MergeTest(_fixtures.FixtureTest):
         sess.add(u)
         sess.flush()
 
-        eq_(on_load.called, 0)
+        eq_(load.called, 0)
 
         sess2 = create_session()
         u2 = sess2.query(User).get(7)
-        eq_(on_load.called, 1)
+        eq_(load.called, 1)
         u2.name = 'fred2'
         u2.address.email_address = 'hoho@lalala.com'
-        eq_(on_load.called, 2)
+        eq_(load.called, 2)
 
         u3 = sess.merge(u2)
-        eq_(on_load.called, 2)
+        eq_(load.called, 2)
         assert u3 is u
 
     @testing.resolve_artifact_names
diff --git a/test/orm/test_session.py b/test/orm/test_session.py
index 8596e585a..9aeea8287 100644
--- a/test/orm/test_session.py
+++ b/test/orm/test_session.py
@@ -1218,10 +1218,10 @@ class SessionEventsTest(_fixtures.FixtureTest):
         def my_listener(*arg, **kw):
             pass
         
-        event.listen(Session, 'on_before_flush', my_listener)
+        event.listen(Session, 'before_flush', my_listener)
         
         s = Session()
-        assert my_listener in s.dispatch.on_before_flush
+        assert my_listener in s.dispatch.before_flush
     
     def test_sessionmaker_listen(self):
         """test that listen can be applied to individual scoped_session() classes."""
@@ -1234,16 +1234,16 @@ class SessionEventsTest(_fixtures.FixtureTest):
         S1 = sessionmaker()
         S2 = sessionmaker()
         
-        event.listen(Session, 'on_before_flush', my_listener_one)
-        event.listen(S1, 'on_before_flush', my_listener_two)
+        event.listen(Session, 'before_flush', my_listener_one)
+        event.listen(S1, 'before_flush', my_listener_two)
         
         s1 = S1()
-        assert my_listener_one in s1.dispatch.on_before_flush
-        assert my_listener_two in s1.dispatch.on_before_flush
+        assert my_listener_one in s1.dispatch.before_flush
+        assert my_listener_two in s1.dispatch.before_flush
         
         s2 = S2()
-        assert my_listener_one in s2.dispatch.on_before_flush
-        assert my_listener_two not in s2.dispatch.on_before_flush
+        assert my_listener_one in s2.dispatch.before_flush
+        assert my_listener_two not in s2.dispatch.before_flush
     
     def test_scoped_session_invalid_callable(self):
         from sqlalchemy.orm import scoped_session
@@ -1257,7 +1257,7 @@ class SessionEventsTest(_fixtures.FixtureTest):
             sa.exc.ArgumentError,
             "Session event listen on a ScopedSession "
             "requries that its creation callable is a Session subclass.",
-            event.listen, scope, "on_before_flush", my_listener_one
+            event.listen, scope, "before_flush", my_listener_one
         )
 
     def test_scoped_session_invalid_class(self):
@@ -1276,7 +1276,7 @@ class SessionEventsTest(_fixtures.FixtureTest):
             sa.exc.ArgumentError,
             "Session event listen on a ScopedSession "
             "requries that its creation callable is a Session subclass.",
-            event.listen, scope, "on_before_flush", my_listener_one
+            event.listen, scope, "before_flush", my_listener_one
         )
     
     def test_scoped_session_listen(self):
@@ -1286,9 +1286,9 @@ class SessionEventsTest(_fixtures.FixtureTest):
             pass
         
         scope = scoped_session(sessionmaker())
-        event.listen(scope, "on_before_flush", my_listener_one)
+        event.listen(scope, "before_flush", my_listener_one)
         
-        assert my_listener_one in scope().dispatch.on_before_flush
+        assert my_listener_one in scope().dispatch.before_flush
     
     def _listener_fixture(self, **kw):
         canary = []
@@ -1300,16 +1300,16 @@ class SessionEventsTest(_fixtures.FixtureTest):
         sess = Session(**kw)
 
         for evt in [
-            'on_before_commit',
-            'on_after_commit',
-            'on_after_rollback',
-            'on_before_flush',
-            'on_after_flush',
-            'on_after_flush_postexec',
-            'on_after_begin',
-            'on_after_attach',
-            'on_after_bulk_update',
-            'on_after_bulk_delete'
+            'before_commit',
+            'after_commit',
+            'after_rollback',
+            'before_flush',
+            'after_flush',
+            'after_flush_postexec',
+            'after_begin',
+            'after_attach',
+            'after_bulk_update',
+            'after_bulk_delete'
         ]:
             event.listen(sess, evt, listener(evt))
         
@@ -1327,9 +1327,9 @@ class SessionEventsTest(_fixtures.FixtureTest):
         sess.flush()
         eq_(
             canary, 
-            [ 'on_after_attach', 'on_before_flush', 'on_after_begin',
-            'on_after_flush', 'on_before_commit', 'on_after_commit',
-            'on_after_flush_postexec', ]
+            [ 'after_attach', 'before_flush', 'after_begin',
+            'after_flush', 'before_commit', 'after_commit',
+            'after_flush_postexec', ]
         )
 
     @testing.resolve_artifact_names
@@ -1341,8 +1341,8 @@ class SessionEventsTest(_fixtures.FixtureTest):
         u = User(name='u1')
         sess.add(u)
         sess.flush()
-        eq_(canary, ['on_after_attach', 'on_before_flush', 'on_after_begin',
-                       'on_after_flush', 'on_after_flush_postexec'])
+        eq_(canary, ['after_attach', 'before_flush', 'after_begin',
+                       'after_flush', 'after_flush_postexec'])
     
     @testing.resolve_artifact_names
     def test_flush_in_commit_hook(self):
@@ -1356,32 +1356,32 @@ class SessionEventsTest(_fixtures.FixtureTest):
         
         u.name = 'ed'
         sess.commit()
-        eq_(canary, ['on_before_commit', 'on_before_flush', 'on_after_flush',
-                       'on_after_flush_postexec', 'on_after_commit'])
+        eq_(canary, ['before_commit', 'before_flush', 'after_flush',
+                       'after_flush_postexec', 'after_commit'])
     
     def test_standalone_on_commit_hook(self):
         sess, canary = self._listener_fixture()
         sess.commit()
-        eq_(canary, ['on_before_commit', 'on_after_commit'])
+        eq_(canary, ['before_commit', 'after_commit'])
         
     @testing.resolve_artifact_names
     def test_on_bulk_update_hook(self):
         sess, canary = self._listener_fixture()
         mapper(User, users)
         sess.query(User).update({'name': 'foo'})
-        eq_(canary, ['on_after_begin', 'on_after_bulk_update'])
+        eq_(canary, ['after_begin', 'after_bulk_update'])
 
     @testing.resolve_artifact_names
     def test_on_bulk_delete_hook(self):
         sess, canary = self._listener_fixture()
         mapper(User, users)
         sess.query(User).delete()
-        eq_(canary, ['on_after_begin', 'on_after_bulk_delete'])
+        eq_(canary, ['after_begin', 'after_bulk_delete'])
     
     def test_connection_emits_after_begin(self):
         sess, canary = self._listener_fixture(bind=testing.db)
         conn = sess.connection()
-        eq_(canary, ['on_after_begin'])
+        eq_(canary, ['after_begin'])
 
     @testing.resolve_artifact_names
     def test_reentrant_flush(self):
@@ -1392,7 +1392,7 @@ class SessionEventsTest(_fixtures.FixtureTest):
             session.flush()
         
         sess = Session()
-        event.listen(sess, 'on_before_flush', before_flush)
+        event.listen(sess, 'before_flush', before_flush)
         sess.add(User(name='foo'))
         assert_raises_message(sa.exc.InvalidRequestError,
                               'already flushing', sess.flush)
@@ -1413,7 +1413,7 @@ class SessionEventsTest(_fixtures.FixtureTest):
                     session.delete(x)
                     
         sess = Session()
-        event.listen(sess, 'on_before_flush', before_flush)
+        event.listen(sess, 'before_flush', before_flush)
 
         u = User(name='u1')
         sess.add(u)
@@ -1460,7 +1460,7 @@ class SessionEventsTest(_fixtures.FixtureTest):
                 obj.name += " modified"
                     
         sess = Session(autoflush=True)
-        event.listen(sess, 'on_before_flush', before_flush)
+        event.listen(sess, 'before_flush', before_flush)
         
         u = User(name='u1')
         sess.add(u)
diff --git a/test/orm/test_unitofwork.py b/test/orm/test_unitofwork.py
index 9c472764e..e85166f68 100644
--- a/test/orm/test_unitofwork.py
+++ b/test/orm/test_unitofwork.py
@@ -1374,8 +1374,8 @@ class SaveTest(_fixtures.FixtureTest):
         mapper(User, users, batch=False)
         
         evt = Events()
-        event.listen(User, "on_before_insert", evt.before_insert)
-        event.listen(User, "on_after_insert", evt.after_insert)
+        event.listen(User, "before_insert", evt.before_insert)
+        event.listen(User, "after_insert", evt.after_insert)
         
         u1 = User(name='user1')
         u2 = User(name='user2')
@@ -1399,8 +1399,8 @@ class SaveTest(_fixtures.FixtureTest):
 
         m = mapper(User, users)
         evt = Events()
-        event.listen(User, "on_before_insert", evt.before_insert)
-        event.listen(User, "on_after_insert", evt.after_insert)
+        event.listen(User, "before_insert", evt.before_insert)
+        event.listen(User, "after_insert", evt.after_insert)
 
         u1 = User(name='user1')
         u2 = User(name='user2')