Add deprecation warnings to all deprecated APIs

A large change throughout the library has ensured that all objects, parameters,
and behaviors which have been noted as deprecated or legacy now emit
``DeprecationWarning`` warnings when invoked.   As the Python 3 interpreter now
defaults to displaying deprecation warnings, as well as that modern test suites
based on tools like tox and pytest tend to display deprecation warnings,
this change should make it easier to note what API features are obsolete.

See the notes added to the changelog and migration notes for further
details.

Fixes: #4393
Change-Id: If0ea11a1fc24f9a8029352eeadfc49a7a54c0a1b

1 files changed, 0 insertions, 424 deletions

diff --git a/test/engine/test_pool.py b/test/engine/test_pool.py
index 75caa233a..feff61b88 100644
--- a/test/engine/test_pool.py
+++ b/test/engine/test_pool.py
@@ -90,50 +90,6 @@ class PoolTestBase(fixtures.TestBase):
 
 
 class PoolTest(PoolTestBase):
-    def test_manager(self):
-        manager = pool.manage(MockDBAPI(), use_threadlocal=True)
-
-        c1 = manager.connect("foo.db")
-        c2 = manager.connect("foo.db")
-        c3 = manager.connect("bar.db")
-        c4 = manager.connect("foo.db", bar="bat")
-        c5 = manager.connect("foo.db", bar="hoho")
-        c6 = manager.connect("foo.db", bar="bat")
-
-        assert c1.cursor() is not None
-        assert c1 is c2
-        assert c1 is not c3
-        assert c4 is c6
-        assert c4 is not c5
-
-    def test_manager_with_key(self):
-
-        dbapi = MockDBAPI()
-        manager = pool.manage(dbapi, use_threadlocal=True)
-
-        c1 = manager.connect("foo.db", sa_pool_key="a")
-        c2 = manager.connect("foo.db", sa_pool_key="b")
-        c3 = manager.connect("bar.db", sa_pool_key="a")
-
-        assert c1.cursor() is not None
-        assert c1 is not c2
-        assert c1 is c3
-
-        eq_(dbapi.connect.mock_calls, [call("foo.db"), call("foo.db")])
-
-    def test_bad_args(self):
-        manager = pool.manage(MockDBAPI())
-        manager.connect(None)
-
-    def test_non_thread_local_manager(self):
-        manager = pool.manage(MockDBAPI(), use_threadlocal=False)
-
-        connection = manager.connect("foo.db")
-        connection2 = manager.connect("foo.db")
-
-        self.assert_(connection.cursor() is not None)
-        self.assert_(connection is not connection2)
-
     @testing.fails_on(
         "+pyodbc", "pyodbc cursor doesn't implement tuple __eq__"
     )
@@ -170,69 +126,6 @@ class PoolTest(PoolTestBase):
             p.dispose()
             p.recreate()
 
-    def test_threadlocal_del(self):
-        self._do_testthreadlocal(useclose=False)
-
-    def test_threadlocal_close(self):
-        self._do_testthreadlocal(useclose=True)
-
-    def _do_testthreadlocal(self, useclose=False):
-        dbapi = MockDBAPI()
-        for p in (
-            pool.QueuePool(
-                creator=dbapi.connect,
-                pool_size=3,
-                max_overflow=-1,
-                use_threadlocal=True,
-            ),
-            pool.SingletonThreadPool(
-                creator=dbapi.connect, use_threadlocal=True
-            ),
-        ):
-            c1 = p.connect()
-            c2 = p.connect()
-            self.assert_(c1 is c2)
-            c3 = p.unique_connection()
-            self.assert_(c3 is not c1)
-            if useclose:
-                c2.close()
-            else:
-                c2 = None
-            c2 = p.connect()
-            self.assert_(c1 is c2)
-            self.assert_(c3 is not c1)
-            if useclose:
-                c2.close()
-            else:
-                c2 = None
-                lazy_gc()
-            if useclose:
-                c1 = p.connect()
-                c2 = p.connect()
-                c3 = p.connect()
-                c3.close()
-                c2.close()
-                self.assert_(c1.connection is not None)
-                c1.close()
-            c1 = c2 = c3 = None
-
-            # extra tests with QueuePool to ensure connections get
-            # __del__()ed when dereferenced
-
-            if isinstance(p, pool.QueuePool):
-                lazy_gc()
-                self.assert_(p.checkedout() == 0)
-                c1 = p.connect()
-                c2 = p.connect()
-                if useclose:
-                    c2.close()
-                    c1.close()
-                else:
-                    c2 = None
-                    c1 = None
-                    lazy_gc()
-                self.assert_(p.checkedout() == 0)
-
     def test_info(self):
         p = self._queuepool_fixture(pool_size=1, max_overflow=0)
 
@@ -822,255 +715,6 @@ class PoolFirstConnectSyncTest(PoolTestBase):
         )
 
 
-class DeprecatedPoolListenerTest(PoolTestBase):
-    @testing.requires.predictable_gc
-    @testing.uses_deprecated(
-        r".*Use the PoolEvents",
-        r".*'listeners' argument .* is deprecated"
-    )
-    def test_listeners(self):
-        class InstrumentingListener(object):
-            def __init__(self):
-                if hasattr(self, "connect"):
-                    self.connect = self.inst_connect
-                if hasattr(self, "first_connect"):
-                    self.first_connect = self.inst_first_connect
-                if hasattr(self, "checkout"):
-                    self.checkout = self.inst_checkout
-                if hasattr(self, "checkin"):
-                    self.checkin = self.inst_checkin
-                self.clear()
-
-            def clear(self):
-                self.connected = []
-                self.first_connected = []
-                self.checked_out = []
-                self.checked_in = []
-
-            def assert_total(self, conn, fconn, cout, cin):
-                eq_(len(self.connected), conn)
-                eq_(len(self.first_connected), fconn)
-                eq_(len(self.checked_out), cout)
-                eq_(len(self.checked_in), cin)
-
-            def assert_in(self, item, in_conn, in_fconn, in_cout, in_cin):
-                eq_((item in self.connected), in_conn)
-                eq_((item in self.first_connected), in_fconn)
-                eq_((item in self.checked_out), in_cout)
-                eq_((item in self.checked_in), in_cin)
-
-            def inst_connect(self, con, record):
-                print("connect(%s, %s)" % (con, record))
-                assert con is not None
-                assert record is not None
-                self.connected.append(con)
-
-            def inst_first_connect(self, con, record):
-                print("first_connect(%s, %s)" % (con, record))
-                assert con is not None
-                assert record is not None
-                self.first_connected.append(con)
-
-            def inst_checkout(self, con, record, proxy):
-                print("checkout(%s, %s, %s)" % (con, record, proxy))
-                assert con is not None
-                assert record is not None
-                assert proxy is not None
-                self.checked_out.append(con)
-
-            def inst_checkin(self, con, record):
-                print("checkin(%s, %s)" % (con, record))
-                # con can be None if invalidated
-                assert record is not None
-                self.checked_in.append(con)
-
-        class ListenAll(tsa.interfaces.PoolListener, InstrumentingListener):
-            pass
-
-        class ListenConnect(InstrumentingListener):
-            def connect(self, con, record):
-                pass
-
-        class ListenFirstConnect(InstrumentingListener):
-            def first_connect(self, con, record):
-                pass
-
-        class ListenCheckOut(InstrumentingListener):
-            def checkout(self, con, record, proxy, num):
-                pass
-
-        class ListenCheckIn(InstrumentingListener):
-            def checkin(self, con, record):
-                pass
-
-        def assert_listeners(p, total, conn, fconn, cout, cin):
-            for instance in (p, p.recreate()):
-                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)
-
-        p.add_listener(ListenAll())
-        assert_listeners(p, 1, 1, 1, 1, 1)
-
-        p.add_listener(ListenConnect())
-        assert_listeners(p, 2, 2, 1, 1, 1)
-
-        p.add_listener(ListenFirstConnect())
-        assert_listeners(p, 3, 2, 2, 1, 1)
-
-        p.add_listener(ListenCheckOut())
-        assert_listeners(p, 4, 2, 2, 2, 1)
-
-        p.add_listener(ListenCheckIn())
-        assert_listeners(p, 5, 2, 2, 2, 2)
-        del p
-
-        snoop = ListenAll()
-        p = self._queuepool_fixture(listeners=[snoop])
-        assert_listeners(p, 1, 1, 1, 1, 1)
-
-        c = p.connect()
-        snoop.assert_total(1, 1, 1, 0)
-        cc = c.connection
-        snoop.assert_in(cc, True, True, True, False)
-        c.close()
-        snoop.assert_in(cc, True, True, True, True)
-        del c, cc
-
-        snoop.clear()
-
-        # this one depends on immediate gc
-        c = p.connect()
-        cc = c.connection
-        snoop.assert_in(cc, False, False, True, False)
-        snoop.assert_total(0, 0, 1, 0)
-        del c, cc
-        lazy_gc()
-        snoop.assert_total(0, 0, 1, 1)
-
-        p.dispose()
-        snoop.clear()
-
-        c = p.connect()
-        c.close()
-        c = p.connect()
-        snoop.assert_total(1, 0, 2, 1)
-        c.close()
-        snoop.assert_total(1, 0, 2, 2)
-
-        # invalidation
-        p.dispose()
-        snoop.clear()
-
-        c = p.connect()
-        snoop.assert_total(1, 0, 1, 0)
-        c.invalidate()
-        snoop.assert_total(1, 0, 1, 1)
-        c.close()
-        snoop.assert_total(1, 0, 1, 1)
-        del c
-        lazy_gc()
-        snoop.assert_total(1, 0, 1, 1)
-        c = p.connect()
-        snoop.assert_total(2, 0, 2, 1)
-        c.close()
-        del c
-        lazy_gc()
-        snoop.assert_total(2, 0, 2, 2)
-
-        # detached
-        p.dispose()
-        snoop.clear()
-
-        c = p.connect()
-        snoop.assert_total(1, 0, 1, 0)
-        c.detach()
-        snoop.assert_total(1, 0, 1, 0)
-        c.close()
-        del c
-        snoop.assert_total(1, 0, 1, 0)
-        c = p.connect()
-        snoop.assert_total(2, 0, 2, 0)
-        c.close()
-        del c
-        snoop.assert_total(2, 0, 2, 1)
-
-        # recreated
-        p = p.recreate()
-        snoop.clear()
-
-        c = p.connect()
-        snoop.assert_total(1, 1, 1, 0)
-        c.close()
-        snoop.assert_total(1, 1, 1, 1)
-        c = p.connect()
-        snoop.assert_total(1, 1, 2, 1)
-        c.close()
-        snoop.assert_total(1, 1, 2, 2)
-
-    @testing.uses_deprecated(
-        r".*Use the PoolEvents",
-        r".*'listeners' argument .* is deprecated"
-    )
-    def test_listeners_callables(self):
-        def connect(dbapi_con, con_record):
-            counts[0] += 1
-
-        def checkout(dbapi_con, con_record, con_proxy):
-            counts[1] += 1
-
-        def checkin(dbapi_con, con_record):
-            counts[2] += 1
-
-        i_all = dict(connect=connect, checkout=checkout, checkin=checkin)
-        i_connect = dict(connect=connect)
-        i_checkout = dict(checkout=checkout)
-        i_checkin = dict(checkin=checkin)
-
-        for cls in (pool.QueuePool, pool.StaticPool):
-            counts = [0, 0, 0]
-
-            def assert_listeners(p, total, conn, cout, cin):
-                for instance in (p, p.recreate()):
-                    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)
-
-            p.add_listener(i_all)
-            assert_listeners(p, 1, 1, 1, 1)
-
-            p.add_listener(i_connect)
-            assert_listeners(p, 2, 1, 1, 1)
-
-            p.add_listener(i_checkout)
-            assert_listeners(p, 3, 1, 1, 1)
-
-            p.add_listener(i_checkin)
-            assert_listeners(p, 4, 1, 1, 1)
-            del p
-
-            p = self._queuepool_fixture(listeners=[i_all])
-            assert_listeners(p, 1, 1, 1, 1)
-
-            c = p.connect()
-            assert counts == [1, 1, 0]
-            c.close()
-            assert counts == [1, 1, 1]
-
-            c = p.connect()
-            assert counts == [1, 2, 1]
-            p.add_listener(i_checkin)
-            c.close()
-            assert counts == [1, 2, 2]
-
-
 class QueuePoolTest(PoolTestBase):
     def test_queuepool_del(self):
         self._do_testqueuepool(useclose=False)
@@ -1491,30 +1135,7 @@ class QueuePoolTest(PoolTestBase):
     def test_max_overflow(self):
         self._test_overflow(40, 5)
 
-    def test_mixed_close(self):
-        pool._refs.clear()
-        p = self._queuepool_fixture(
-            pool_size=3, max_overflow=-1, use_threadlocal=True
-        )
-        c1 = p.connect()
-        c2 = p.connect()
-        assert c1 is c2
-        c1.close()
-        c2 = None
-        assert p.checkedout() == 1
-        c1 = None
-        lazy_gc()
-        assert p.checkedout() == 0
-        lazy_gc()
-        assert not pool._refs
-
-    def test_overflow_no_gc_tlocal(self):
-        self._test_overflow_no_gc(True)
-
     def test_overflow_no_gc(self):
-        self._test_overflow_no_gc(False)
-
-    def _test_overflow_no_gc(self, threadlocal):
         p = self._queuepool_fixture(pool_size=2, max_overflow=2)
 
         # disable weakref collection of the
@@ -1543,42 +1164,6 @@ class QueuePoolTest(PoolTestBase):
             set([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0]),
         )
 
-    @testing.requires.predictable_gc
-    def test_weakref_kaboom(self):
-        p = self._queuepool_fixture(
-            pool_size=3, max_overflow=-1, use_threadlocal=True
-        )
-        c1 = p.connect()
-        c2 = p.connect()
-        c1.close()
-        c2 = None
-        del c1
-        del c2
-        gc_collect()
-        assert p.checkedout() == 0
-        c3 = p.connect()
-        assert c3 is not None
-
-    def test_trick_the_counter(self):
-        """this is a "flaw" in the connection pool; since threadlocal
-        uses a single ConnectionFairy per thread with an open/close
-        counter, you can fool the counter into giving you a
-        ConnectionFairy with an ambiguous counter.  i.e. its not true
-        reference counting."""
-
-        p = self._queuepool_fixture(
-            pool_size=3, max_overflow=-1, use_threadlocal=True
-        )
-        c1 = p.connect()
-        c2 = p.connect()
-        assert c1 is c2
-        c1.close()
-        c2 = p.connect()
-        c2.close()
-        self.assert_(p.checkedout() != 0)
-        c2.close()
-        self.assert_(p.checkedout() == 0)
-
     def test_recycle(self):
         with patch("sqlalchemy.pool.base.time.time") as mock:
             mock.return_value = 10000
@@ -1957,15 +1542,6 @@ class QueuePoolTest(PoolTestBase):
         c2.close()
         eq_(c2_con.close.call_count, 0)
 
-    def test_threadfairy(self):
-        p = self._queuepool_fixture(
-            pool_size=3, max_overflow=-1, use_threadlocal=True
-        )
-        c1 = p.connect()
-        c1.close()
-        c2 = p.connect()
-        assert c2.connection is not None
-
     def test_no_double_checkin(self):
         p = self._queuepool_fixture(pool_size=1)