Clean up .execute calls in test_select.py

Change-Id: I97dfb59d13a7c27c79c3dbcbcb5ba61948569e46

1 files changed, 101 insertions, 87 deletions

diff --git a/lib/sqlalchemy/testing/suite/test_select.py b/lib/sqlalchemy/testing/suite/test_select.py
index 2c2317ff7..229f8b819 100644
--- a/lib/sqlalchemy/testing/suite/test_select.py
+++ b/lib/sqlalchemy/testing/suite/test_select.py
@@ -42,16 +42,18 @@ class CollateTest(fixtures.TablesTest):
 
     @classmethod
     def insert_data(cls):
-        config.db.execute(
-            cls.tables.some_table.insert(),
-            [
-                {"id": 1, "data": "collate data1"},
-                {"id": 2, "data": "collate data2"},
-            ],
-        )
+        with config.db.connect() as conn:
+            conn.execute(
+                cls.tables.some_table.insert(),
+                [
+                    {"id": 1, "data": "collate data1"},
+                    {"id": 2, "data": "collate data2"},
+                ],
+            )
 
     def _assert_result(self, select, result):
-        eq_(config.db.execute(select).fetchall(), result)
+        with config.db.connect() as conn:
+            eq_(conn.execute(select).fetchall(), result)
 
     @testing.requires.order_by_collation
     def test_collate_order_by(self):
@@ -90,17 +92,19 @@ class OrderByLabelTest(fixtures.TablesTest):
 
     @classmethod
     def insert_data(cls):
-        config.db.execute(
-            cls.tables.some_table.insert(),
-            [
-                {"id": 1, "x": 1, "y": 2, "q": "q1", "p": "p3"},
-                {"id": 2, "x": 2, "y": 3, "q": "q2", "p": "p2"},
-                {"id": 3, "x": 3, "y": 4, "q": "q3", "p": "p1"},
-            ],
-        )
+        with config.db.connect() as conn:
+            conn.execute(
+                cls.tables.some_table.insert(),
+                [
+                    {"id": 1, "x": 1, "y": 2, "q": "q1", "p": "p3"},
+                    {"id": 2, "x": 2, "y": 3, "q": "q2", "p": "p2"},
+                    {"id": 3, "x": 3, "y": 4, "q": "q3", "p": "p1"},
+                ],
+            )
 
     def _assert_result(self, select, result):
-        eq_(config.db.execute(select).fetchall(), result)
+        with config.db.connect() as conn:
+            eq_(conn.execute(select).fetchall(), result)
 
     def test_plain(self):
         table = self.tables.some_table
@@ -162,18 +166,20 @@ class LimitOffsetTest(fixtures.TablesTest):
 
     @classmethod
     def insert_data(cls):
-        config.db.execute(
-            cls.tables.some_table.insert(),
-            [
-                {"id": 1, "x": 1, "y": 2},
-                {"id": 2, "x": 2, "y": 3},
-                {"id": 3, "x": 3, "y": 4},
-                {"id": 4, "x": 4, "y": 5},
-            ],
-        )
+        with config.db.connect() as conn:
+            conn.execute(
+                cls.tables.some_table.insert(),
+                [
+                    {"id": 1, "x": 1, "y": 2},
+                    {"id": 2, "x": 2, "y": 3},
+                    {"id": 3, "x": 3, "y": 4},
+                    {"id": 4, "x": 4, "y": 5},
+                ],
+            )
 
     def _assert_result(self, select, result, params=()):
-        eq_(config.db.execute(select, params).fetchall(), result)
+        with config.db.connect() as conn:
+            eq_(conn.execute(select, params).fetchall(), result)
 
     def _assert_result_str(self, select, result, params=()):
         conn = config.db.connect(close_with_result=True)
@@ -303,7 +309,8 @@ class JoinTest(fixtures.TablesTest):
     __backend__ = True
 
     def _assert_result(self, select, result, params=()):
-        eq_(config.db.execute(select, params).fetchall(), result)
+        with config.db.connect() as conn:
+            eq_(conn.execute(select, params).fetchall(), result)
 
     @classmethod
     def define_tables(cls, metadata):
@@ -317,20 +324,21 @@ class JoinTest(fixtures.TablesTest):
 
     @classmethod
     def insert_data(cls):
-        config.db.execute(
-            cls.tables.a.insert(),
-            [{"id": 1}, {"id": 2}, {"id": 3}, {"id": 4}, {"id": 5}],
-        )
+        with config.db.connect() as conn:
+            conn.execute(
+                cls.tables.a.insert(),
+                [{"id": 1}, {"id": 2}, {"id": 3}, {"id": 4}, {"id": 5}],
+            )
 
-        config.db.execute(
-            cls.tables.b.insert(),
-            [
-                {"id": 1, "a_id": 1},
-                {"id": 2, "a_id": 1},
-                {"id": 4, "a_id": 2},
-                {"id": 5, "a_id": 3},
-            ],
-        )
+            conn.execute(
+                cls.tables.b.insert(),
+                [
+                    {"id": 1, "a_id": 1},
+                    {"id": 2, "a_id": 1},
+                    {"id": 4, "a_id": 2},
+                    {"id": 5, "a_id": 3},
+                ],
+            )
 
     def test_inner_join_fk(self):
         a, b = self.tables("a", "b")
@@ -413,18 +421,20 @@ class CompoundSelectTest(fixtures.TablesTest):
 
     @classmethod
     def insert_data(cls):
-        config.db.execute(
-            cls.tables.some_table.insert(),
-            [
-                {"id": 1, "x": 1, "y": 2},
-                {"id": 2, "x": 2, "y": 3},
-                {"id": 3, "x": 3, "y": 4},
-                {"id": 4, "x": 4, "y": 5},
-            ],
-        )
+        with config.db.connect() as conn:
+            conn.execute(
+                cls.tables.some_table.insert(),
+                [
+                    {"id": 1, "x": 1, "y": 2},
+                    {"id": 2, "x": 2, "y": 3},
+                    {"id": 3, "x": 3, "y": 4},
+                    {"id": 4, "x": 4, "y": 5},
+                ],
+            )
 
     def _assert_result(self, select, result, params=()):
-        eq_(config.db.execute(select, params).fetchall(), result)
+        with config.db.connect() as conn:
+            eq_(conn.execute(select, params).fetchall(), result)
 
     def test_plain_union(self):
         table = self.tables.some_table
@@ -556,15 +566,16 @@ class PostCompileParamsTest(
 
     @classmethod
     def insert_data(cls):
-        config.db.execute(
-            cls.tables.some_table.insert(),
-            [
-                {"id": 1, "x": 1, "y": 2, "z": "z1"},
-                {"id": 2, "x": 2, "y": 3, "z": "z2"},
-                {"id": 3, "x": 3, "y": 4, "z": "z3"},
-                {"id": 4, "x": 4, "y": 5, "z": "z4"},
-            ],
-        )
+        with config.db.connect() as conn:
+            conn.execute(
+                cls.tables.some_table.insert(),
+                [
+                    {"id": 1, "x": 1, "y": 2, "z": "z1"},
+                    {"id": 2, "x": 2, "y": 3, "z": "z2"},
+                    {"id": 3, "x": 3, "y": 4, "z": "z3"},
+                    {"id": 4, "x": 4, "y": 5, "z": "z4"},
+                ],
+            )
 
     def test_compile(self):
         table = self.tables.some_table
@@ -673,18 +684,20 @@ class ExpandingBoundInTest(fixtures.TablesTest):
 
     @classmethod
     def insert_data(cls):
-        config.db.execute(
-            cls.tables.some_table.insert(),
-            [
-                {"id": 1, "x": 1, "y": 2, "z": "z1"},
-                {"id": 2, "x": 2, "y": 3, "z": "z2"},
-                {"id": 3, "x": 3, "y": 4, "z": "z3"},
-                {"id": 4, "x": 4, "y": 5, "z": "z4"},
-            ],
-        )
+        with config.db.connect() as conn:
+            conn.execute(
+                cls.tables.some_table.insert(),
+                [
+                    {"id": 1, "x": 1, "y": 2, "z": "z1"},
+                    {"id": 2, "x": 2, "y": 3, "z": "z2"},
+                    {"id": 3, "x": 3, "y": 4, "z": "z3"},
+                    {"id": 4, "x": 4, "y": 5, "z": "z4"},
+                ],
+            )
 
     def _assert_result(self, select, result, params=()):
-        eq_(config.db.execute(select, params).fetchall(), result)
+        with config.db.connect() as conn:
+            eq_(conn.execute(select, params).fetchall(), result)
 
     def test_multiple_empty_sets(self):
         # test that any anonymous aliasing used by the dialect
@@ -837,7 +850,7 @@ class ExpandingBoundInTest(fixtures.TablesTest):
 
         self._assert_result(stmt, [(1,), (2,), (3,), (4,)], params={"q": []})
 
-    def test_null_in_empty_set_is_false(self):
+    def test_null_in_empty_set_is_false(self, connection):
         stmt = select(
             [
                 case(
@@ -853,7 +866,7 @@ class ExpandingBoundInTest(fixtures.TablesTest):
                 )
             ]
         )
-        in_(config.db.execute(stmt).fetchone()[0], (False, 0))
+        in_(connection.execute(stmt).fetchone()[0], (False, 0))
 
 
 class LikeFunctionsTest(fixtures.TablesTest):
@@ -873,21 +886,22 @@ class LikeFunctionsTest(fixtures.TablesTest):
 
     @classmethod
     def insert_data(cls):
-        config.db.execute(
-            cls.tables.some_table.insert(),
-            [
-                {"id": 1, "data": "abcdefg"},
-                {"id": 2, "data": "ab/cdefg"},
-                {"id": 3, "data": "ab%cdefg"},
-                {"id": 4, "data": "ab_cdefg"},
-                {"id": 5, "data": "abcde/fg"},
-                {"id": 6, "data": "abcde%fg"},
-                {"id": 7, "data": "ab#cdefg"},
-                {"id": 8, "data": "ab9cdefg"},
-                {"id": 9, "data": "abcde#fg"},
-                {"id": 10, "data": "abcd9fg"},
-            ],
-        )
+        with config.db.connect() as conn:
+            conn.execute(
+                cls.tables.some_table.insert(),
+                [
+                    {"id": 1, "data": "abcdefg"},
+                    {"id": 2, "data": "ab/cdefg"},
+                    {"id": 3, "data": "ab%cdefg"},
+                    {"id": 4, "data": "ab_cdefg"},
+                    {"id": 5, "data": "abcde/fg"},
+                    {"id": 6, "data": "abcde%fg"},
+                    {"id": 7, "data": "ab#cdefg"},
+                    {"id": 8, "data": "ab9cdefg"},
+                    {"id": 9, "data": "abcde#fg"},
+                    {"id": 10, "data": "abcd9fg"},
+                ],
+            )
 
     def _test(self, expr, expected):
         some_table = self.tables.some_table