new calling style: event.listen(target, identifier, fn)

12 files changed, 110 insertions, 112 deletions

diff --git a/test/base/test_events.py b/test/base/test_events.py
index 1baed241b..5fce23724 100644
--- a/test/base/test_events.py
+++ b/test/base/test_events.py
@@ -29,7 +29,7 @@ class TestEvents(TestBase):
         def listen(x, y):
             pass
         
-        event.listen(listen, "on_event_one", Target)
+        event.listen(Target, "on_event_one", listen)
         
         eq_(len(Target().dispatch.on_event_one), 1)
         eq_(len(Target().dispatch.on_event_two), 0)
@@ -39,7 +39,7 @@ class TestEvents(TestBase):
             pass
         
         t1 = Target()
-        event.listen(listen, "on_event_one", t1)
+        event.listen(t1, "on_event_one", listen)
 
         eq_(len(Target().dispatch.on_event_one), 0)
         eq_(len(t1.dispatch.on_event_one), 1)
@@ -53,10 +53,10 @@ class TestEvents(TestBase):
         def listen_two(x, y):
             pass
 
-        event.listen(listen_one, "on_event_one", Target)
+        event.listen(Target, "on_event_one", listen_one)
         
         t1 = Target()
-        event.listen(listen_two, "on_event_one", t1)
+        event.listen(t1, "on_event_one", listen_two)
 
         eq_(len(Target().dispatch.on_event_one), 1)
         eq_(len(t1.dispatch.on_event_one), 2)
@@ -66,7 +66,7 @@ class TestEvents(TestBase):
         def listen_three(x, y):
             pass
         
-        event.listen(listen_three, "on_event_one", Target)
+        event.listen(Target, "on_event_one", listen_three)
         eq_(len(Target().dispatch.on_event_one), 2)
         eq_(len(t1.dispatch.on_event_one), 3)
         
@@ -111,8 +111,8 @@ class TestAcceptTargets(TestBase):
         def listen_four(x, y):
             pass
             
-        event.listen(listen_one, "on_event_one", TargetOne)
-        event.listen(listen_two, "on_event_one", TargetTwo)
+        event.listen(TargetOne, "on_event_one", listen_one)
+        event.listen(TargetTwo, "on_event_one", listen_two)
         
         eq_(
             list(TargetOne().dispatch.on_event_one),
@@ -127,8 +127,8 @@ class TestAcceptTargets(TestBase):
         t1 = TargetOne()
         t2 = TargetTwo()
 
-        event.listen(listen_three, "on_event_one", t1)
-        event.listen(listen_four, "on_event_one", t2)
+        event.listen(t1, "on_event_one", listen_three)
+        event.listen(t2, "on_event_one", listen_four)
         
         eq_(
             list(t1.dispatch.on_event_one),
@@ -167,7 +167,7 @@ class TestCustomTargets(TestBase):
         def listen(x, y):
             pass
         
-        event.listen(listen, "on_event_one", "one")
+        event.listen("one", "on_event_one", listen)
 
         eq_(
             list(Target().dispatch.on_event_one),
@@ -188,14 +188,14 @@ class TestListenOverride(TestBase):
         
         class TargetEvents(event.Events):
             @classmethod
-            def listen(cls, fn, identifier, target, add=False):
+            def listen(cls, target, identifier, fn, add=False):
                 if add:
                     def adapt(x, y):
                         fn(x + y)
                 else:
                     adapt = fn
                     
-                event.Events.listen(adapt, identifier, target)
+                event.Events.listen(target, identifier, adapt)
                     
             def on_event_one(self, x, y):
                 pass
@@ -214,8 +214,8 @@ class TestListenOverride(TestBase):
         def listen_two(x, y):
             result.append((x, y))
         
-        event.listen(listen_one, "on_event_one", Target, add=True)
-        event.listen(listen_two, "on_event_one", Target)
+        event.listen(Target, "on_event_one", listen_one, add=True)
+        event.listen(Target, "on_event_one", listen_two)
 
         t1 = Target()
         t1.dispatch.on_event_one(5, 7)
@@ -252,8 +252,8 @@ class TestPropagate(TestBase):
         
         t1 = Target()
         
-        event.listen(listen_one, "on_event_one", t1, propagate=True)
-        event.listen(listen_two, "on_event_two", t1)
+        event.listen(t1, "on_event_one", listen_one, propagate=True)
+        event.listen(t1, "on_event_two", listen_two)
 
         t2 = Target()
         
diff --git a/test/engine/test_ddlevents.py b/test/engine/test_ddlevents.py
index 733cc1fcf..e0e121242 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(canary.before_create, 'on_before_create', table)
+        event.listen(table, 'on_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(canary.after_create, 'on_after_create', table)
+        event.listen(table, 'on_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(canary.before_create, 'on_before_create', table)
-        event.listen(canary.after_create, 'on_after_create', table)
+        event.listen(table, 'on_before_create', canary.before_create)
+        event.listen(table, 'on_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(canary.before_drop, 'on_before_drop', table)
+        event.listen(table, 'on_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(canary.after_drop, 'on_after_drop', table)
+        event.listen(table, 'on_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(canary.before_drop, 'on_before_drop', table)
-        event.listen(canary.after_drop, 'on_after_drop', table)
+        event.listen(table, 'on_before_drop', canary.before_drop)
+        event.listen(table, 'on_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(canary.before_create, 'on_before_create', table)
-        event.listen(canary.after_create, 'on_after_create', table)
-        event.listen(canary.before_drop, 'on_before_drop', table)
-        event.listen(canary.after_drop, 'on_after_drop', table)
+        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)
 
         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(canary.before_create, 'on_before_create', metadata)
+        event.listen(metadata, 'on_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(canary.after_create, 'on_after_create', metadata)
+        event.listen(metadata, 'on_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(canary.before_create, 'on_before_create', metadata)
-        event.listen(canary.after_create, 'on_after_create', metadata)
+        event.listen(metadata, 'on_before_create', canary.before_create)
+        event.listen(metadata, 'on_after_create', canary.after_create)
 
         metadata.create_all(bind)
         assert canary.state == 'after-create'
@@ -164,11 +164,10 @@ class DDLEventTest(TestBase):
         metadata, table, bind = self.metadata, self.table, self.bind
         table_canary = self.Canary(table, bind)
 
-        event.listen(table_canary.before_create, 'on_before_create', table)
+        event.listen(table, 'on_before_create', table_canary.before_create)
 
         metadata_canary = self.Canary(metadata, bind)
-        event.listen(metadata_canary.before_create, 'on_before_create',
-                                                metadata)
+        event.listen(metadata, 'on_before_create', metadata_canary.before_create)
         self.table.create(self.bind)
         assert metadata_canary.state == None
 
@@ -197,10 +196,10 @@ class DDLExecutionTest(TestBase):
 
     def test_table_standalone(self):
         users, engine = self.users, self.engine
-        event.listen(DDL('mxyzptlk'), 'on_before_create', users)
-        event.listen(DDL('klptzyxm'), 'on_after_create', users)
-        event.listen(DDL('xyzzy'), 'on_before_drop', users)
-        event.listen(DDL('fnord'), 'on_after_drop', users)
+        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'))
 
         users.create()
         strings = [str(x) for x in engine.mock]
@@ -219,10 +218,10 @@ class DDLExecutionTest(TestBase):
     def test_table_by_metadata(self):
         metadata, users, engine = self.metadata, self.users, self.engine
 
-        event.listen(DDL('mxyzptlk'), 'on_before_create', users)
-        event.listen(DDL('klptzyxm'), 'on_after_create', users)
-        event.listen(DDL('xyzzy'), 'on_before_drop', users)
-        event.listen(DDL('fnord'), 'on_after_drop', users)
+        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'))
 
         metadata.create_all()
         strings = [str(x) for x in engine.mock]
@@ -264,10 +263,10 @@ class DDLExecutionTest(TestBase):
     def test_metadata(self):
         metadata, engine = self.metadata, self.engine
 
-        event.listen(DDL('mxyzptlk'), 'on_before_create', metadata)
-        event.listen(DDL('klptzyxm'), 'on_after_create', metadata)
-        event.listen(DDL('xyzzy'), 'on_before_drop', metadata)
-        event.listen(DDL('fnord'), 'on_after_drop', metadata)
+        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'))
 
         metadata.create_all()
         strings = [str(x) for x in engine.mock]
@@ -317,15 +316,15 @@ class DDLExecutionTest(TestBase):
         # 'inline_ddl' flag is set to False
 
         event.listen(
-            AddConstraint(constraint).execute_if(dialect='postgresql'),
+            users,
             'on_after_create',
-            users
+            AddConstraint(constraint).execute_if(dialect='postgresql'),
         )
         
         event.listen(
-            DropConstraint(constraint).execute_if(dialect='postgresql'),
+            users,
             'on_before_drop',
-            users
+            DropConstraint(constraint).execute_if(dialect='postgresql'),
         )
         
         metadata.create_all(bind=nonpg_mock)
diff --git a/test/engine/test_execute.py b/test/engine/test_execute.py
index 6b0e86e2f..3bbf9d71a 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(execute, 'on_before_execute', engine)
-            event.listen(cursor_execute, 'on_before_cursor_execute', engine)
+            event.listen(engine, 'on_before_execute', execute)
+            event.listen(engine, 'on_before_cursor_execute', cursor_execute)
             
             m = MetaData(engine)
             t1 = Table('t1', m, 
@@ -528,8 +528,8 @@ class EngineEventsTest(TestBase):
             canary.append('cursor_execute')
             
         engine = engines.testing_engine()
-        event.listen(on_execute, 'on_before_execute', engine)
-        event.listen(on_cursor_execute, 'on_before_cursor_execute', engine)
+        event.listen(engine, 'on_before_execute', on_execute)
+        event.listen(engine, 'on_before_cursor_execute', on_cursor_execute)
         conn = engine.connect()
         c2 = conn.execution_options(foo='bar')
         eq_(c2._execution_options, {'foo':'bar'})
@@ -558,11 +558,11 @@ class EngineEventsTest(TestBase):
         
         assert_raises(
             tsa.exc.ArgumentError,
-            event.listen, tracker("on_begin"), "on_begin", engine, retval=True
+            event.listen, engine, "on_begin", tracker("on_begin"), retval=True
         )
         
-        event.listen(on_execute, "on_before_execute", engine, retval=True)
-        event.listen(on_cursor_execute, "on_before_cursor_execute", engine, retval=True)
+        event.listen(engine, "on_before_execute", on_execute, retval=True)
+        event.listen(engine, "on_before_cursor_execute", on_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(tracker('execute'), 'on_before_execute', engine)
-        event.listen(tracker('cursor_execute'), 'on_before_cursor_execute', engine)
-        event.listen(tracker('begin'), 'on_begin', engine)
-        event.listen(tracker('commit'), 'on_commit', engine)
-        event.listen(tracker('rollback'), 'on_rollback', 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'))
         
         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(tracker(name), 'on_%s' % name, engine)
+            event.listen(engine, 'on_%s' % name, tracker(name))
 
         conn = engine.connect()
 
diff --git a/test/engine/test_pool.py b/test/engine/test_pool.py
index 4da3a08e3..91f675b84 100644
--- a/test/engine/test_pool.py
+++ b/test/engine/test_pool.py
@@ -199,7 +199,7 @@ class PoolEventsTest(PoolTestBase):
         def on_first_connect(*arg, **kw):
             canary.append('first_connect')
         
-        event.listen(on_first_connect, 'on_first_connect', p)
+        event.listen(p, 'on_first_connect', on_first_connect)
         
         return p, canary
 
@@ -208,7 +208,7 @@ class PoolEventsTest(PoolTestBase):
         canary = []
         def on_connect(*arg, **kw):
             canary.append('connect')
-        event.listen(on_connect, 'on_connect', p)
+        event.listen(p, 'on_connect', on_connect)
         
         return p, canary
 
@@ -217,7 +217,7 @@ class PoolEventsTest(PoolTestBase):
         canary = []
         def on_checkout(*arg, **kw):
             canary.append('checkout')
-        event.listen(on_checkout, 'on_checkout', p)
+        event.listen(p, 'on_checkout', on_checkout)
         
         return p, canary
 
@@ -226,7 +226,7 @@ class PoolEventsTest(PoolTestBase):
         canary = []
         def on_checkin(*arg, **kw):
             canary.append('checkin')
-        event.listen(on_checkin, 'on_checkin', p)
+        event.listen(p, 'on_checkin', on_checkin)
         
         return p, canary
         
@@ -361,10 +361,10 @@ class PoolEventsTest(PoolTestBase):
             canary.append("listen_four")
             
         engine = create_engine(testing.db.url)
-        event.listen(listen_one, 'on_connect', pool.Pool)
-        event.listen(listen_two, 'on_connect', engine.pool)
-        event.listen(listen_three, 'on_connect', engine)
-        event.listen(listen_four, 'on_connect', engine.__class__)
+        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)
 
         engine.execute(select([1])).close()
         eq_(
@@ -382,9 +382,9 @@ class PoolEventsTest(PoolTestBase):
         def listen_three(*args):
             canary.append("listen_three")
         
-        event.listen(listen_one, 'on_connect', pool.Pool)
-        event.listen(listen_two, 'on_connect', pool.QueuePool)
-        event.listen(listen_three, 'on_connect', pool.SingletonThreadPool)
+        event.listen(pool.Pool, 'on_connect', listen_one)
+        event.listen(pool.QueuePool, 'on_connect', listen_two)
+        event.listen(pool.SingletonThreadPool, 'on_connect', listen_three)
         
         p1 = pool.QueuePool(creator=MockDBAPI().connect)
         p2 = pool.SingletonThreadPool(creator=MockDBAPI().connect)
diff --git a/test/lib/engines.py b/test/lib/engines.py
index fdf4163c8..0f3ccf288 100644
--- a/test/lib/engines.py
+++ b/test/lib/engines.py
@@ -135,9 +135,9 @@ def testing_engine(url=None, options=None):
     options = options or config.db_opts
 
     engine = create_engine(url, **options)
-    event.listen(asserter.execute, 'on_after_execute', engine)
-    event.listen(asserter.cursor_execute, 'on_after_cursor_execute', engine)
-    event.listen(testing_reaper.checkout, 'on_checkout', engine.pool)
+    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)
     
     # 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 82859cd54..395911b64 100644
--- a/test/orm/test_attributes.py
+++ b/test/orm/test_attributes.py
@@ -1592,9 +1592,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(on_set, 'on_set', Foo.data, retval=True)
-        event.listen(on_append, 'on_append', Foo.barlist, retval=True)
-        event.listen(on_append, 'on_append', Foo.barset, retval=True)
+        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)
         
         f1 = Foo()
         f1.data = "some data"
@@ -1648,7 +1648,7 @@ class ListenerTest(_base.ORMTest):
             canary.append(value)
             
         def events_a():
-            event.listen(on_set, 'on_set', classes[0].attrib, propagate=True)
+            event.listen(classes[0].attrib, 'on_set', on_set, propagate=True)
         
         def teardown():
             classes[:] = [None, None, None]
diff --git a/test/orm/test_defaults.py b/test/orm/test_defaults.py
index e5f419ccb..278eaf0b6 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(ins, 'on_after_create', dt)
+            event.listen(dt, 'on_after_create', ins)
         
-        event.listen(sa.DDL("DROP TRIGGER dt_ins"), 'on_before_drop', dt)
+        event.listen(dt, 'on_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(up, 'on_after_create', dt)
+            event.listen(dt, 'on_after_create', up)
 
-        event.listen(sa.DDL("DROP TRIGGER dt_up"), 'on_before_drop', dt)
+        event.listen(dt, 'on_before_drop', sa.DDL("DROP TRIGGER dt_up"))
 
 
     @classmethod
diff --git a/test/orm/test_instrumentation.py b/test/orm/test_instrumentation.py
index 4bcf36351..4b3701350 100644
--- a/test/orm/test_instrumentation.py
+++ b/test/orm/test_instrumentation.py
@@ -48,7 +48,7 @@ class InitTest(_base.ORMTest):
         manager = instrumentation.manager_of_class(cls)
         def on_init(state, args, kwargs):
             canary.append((cls, 'on_init', state.class_))
-        event.listen(on_init, 'on_init', manager, raw=True)
+        event.listen(manager, 'on_init', on_init, raw=True)
 
     def test_ai(self):
         inits = []
@@ -554,7 +554,7 @@ class OnLoadTest(_base.ORMTest):
         try:
             instrumentation.register_class(A)
             manager = instrumentation.manager_of_class(A)
-            event.listen(canary, 'on_load', manager)
+            event.listen(manager, 'on_load', canary)
 
             a = A()
             p_a = pickle.dumps(a)
diff --git a/test/orm/test_mapper.py b/test/orm/test_mapper.py
index 4f7491ee6..09f9e9a86 100644
--- a/test/orm/test_mapper.py
+++ b/test/orm/test_mapper.py
@@ -2580,11 +2580,11 @@ class MapperEventsTest(_fixtures.FixtureTest):
         def on_init_e(target, args, kwargs):
             canary.append(('on_init_e', target))
         
-        event.listen(on_init_a, 'on_init', mapper)
-        event.listen(on_init_b, 'on_init', Mapper)
-        event.listen(on_init_c, 'on_init', class_mapper(A))
-        event.listen(on_init_d, 'on_init', A)
-        event.listen(on_init_e, 'on_init', A, propagate=True)
+        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)
         
         a = A()
         eq_(canary, [('on_init_a', a),('on_init_b', a),
@@ -2624,7 +2624,7 @@ class MapperEventsTest(_fixtures.FixtureTest):
             'on_before_delete',
             'on_after_delete'
         ]:
-            event.listen(evt(meth), meth, mapper, **kw)
+            event.listen(mapper, meth, evt(meth), **kw)
         return canary
 
     @testing.resolve_artifact_names
@@ -2732,8 +2732,7 @@ class MapperEventsTest(_fixtures.FixtureTest):
             return u
             
         mapper(User, users)
-        event.listen(create_instance, 'on_create_instance', 
-                        User, retval=True)
+        event.listen(User, 'on_create_instance', create_instance, retval=True)
         sess = create_session()
         u1 = User()
         u1.name = 'ed'
@@ -2749,7 +2748,7 @@ class MapperEventsTest(_fixtures.FixtureTest):
         def on_instrument_class(mapper, cls):
             canary.append(cls)
             
-        event.listen(on_instrument_class, 'on_instrument_class', Mapper)
+        event.listen(Mapper, 'on_instrument_class', on_instrument_class)
         
         mapper(User, users)
         eq_(canary, [User])
diff --git a/test/orm/test_merge.py b/test/orm/test_merge.py
index 8effd6665..5329fb71c 100644
--- a/test/orm/test_merge.py
+++ b/test/orm/test_merge.py
@@ -24,7 +24,7 @@ class MergeTest(_fixtures.FixtureTest):
                 canary.called += 1
             canary.called = 0
 
-        event.listen(canary, 'on_load', cls)
+        event.listen(cls, 'on_load', canary)
 
         return canary
 
diff --git a/test/orm/test_session.py b/test/orm/test_session.py
index 7dac00324..ed7a8dda6 100644
--- a/test/orm/test_session.py
+++ b/test/orm/test_session.py
@@ -1218,7 +1218,7 @@ class SessionEventsTest(_fixtures.FixtureTest):
         def my_listener(*arg, **kw):
             pass
         
-        event.listen(my_listener, 'on_before_flush', Session)
+        event.listen(Session, 'on_before_flush', my_listener)
         
         s = Session()
         assert my_listener in s.dispatch.on_before_flush
@@ -1234,8 +1234,8 @@ class SessionEventsTest(_fixtures.FixtureTest):
         S1 = sessionmaker()
         S2 = sessionmaker()
         
-        event.listen(my_listener_one, 'on_before_flush', Session)
-        event.listen(my_listener_two, 'on_before_flush', S1)
+        event.listen(Session, 'on_before_flush', my_listener_one)
+        event.listen(S1, 'on_before_flush', my_listener_two)
         
         s1 = S1()
         assert my_listener_one in s1.dispatch.on_before_flush
@@ -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, my_listener_one, "on_before_flush", scope
+            event.listen, scope, "on_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, my_listener_one, "on_before_flush", scope
+            event.listen, scope, "on_before_flush", my_listener_one
         )
     
     def test_scoped_session_listen(self):
@@ -1286,7 +1286,7 @@ class SessionEventsTest(_fixtures.FixtureTest):
             pass
         
         scope = scoped_session(sessionmaker())
-        event.listen(my_listener_one, "on_before_flush", scope)
+        event.listen(scope, "on_before_flush", my_listener_one)
         
         assert my_listener_one in scope().dispatch.on_before_flush
     
@@ -1311,7 +1311,7 @@ class SessionEventsTest(_fixtures.FixtureTest):
             'on_after_bulk_update',
             'on_after_bulk_delete'
         ]:
-            event.listen(listener(evt), evt, sess)
+            event.listen(sess, evt, listener(evt))
         
         return sess, canary
         
@@ -1392,7 +1392,7 @@ class SessionEventsTest(_fixtures.FixtureTest):
             session.flush()
         
         sess = Session()
-        event.listen(before_flush, 'on_before_flush', sess)
+        event.listen(sess, 'on_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(before_flush, 'on_before_flush', sess)
+        event.listen(sess, 'on_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(before_flush, 'on_before_flush', sess)
+        event.listen(sess, 'on_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 6b6251d66..469464fd0 100644
--- a/test/orm/test_unitofwork.py
+++ b/test/orm/test_unitofwork.py
@@ -1706,8 +1706,8 @@ class SaveTest(_fixtures.FixtureTest):
         mapper(User, users, batch=False)
         
         evt = Events()
-        event.listen(evt.before_insert, "on_before_insert", User)
-        event.listen(evt.after_insert, "on_after_insert", User)
+        event.listen(User, "on_before_insert", evt.before_insert)
+        event.listen(User, "on_after_insert", evt.after_insert)
         
         u1 = User(name='user1')
         u2 = User(name='user2')
@@ -1731,8 +1731,8 @@ class SaveTest(_fixtures.FixtureTest):
 
         m = mapper(User, users)
         evt = Events()
-        event.listen(evt.before_insert, "on_before_insert", User)
-        event.listen(evt.after_insert, "on_after_insert", User)
+        event.listen(User, "on_before_insert", evt.before_insert)
+        event.listen(User, "on_after_insert", evt.after_insert)
 
         u1 = User(name='user1')
         u2 = User(name='user2')