Try running pyupgrade on the code

command run is "pyupgrade --py37-plus --keep-runtime-typing --keep-percent-format <files...>"
pyupgrade will change assert_ to assertTrue. That was reverted since assertTrue does not
exists in sqlalchemy fixtures

Change-Id: Ie1ed2675c7b11d893d78e028aad0d1576baebb55

3 files changed, 82 insertions, 102 deletions

diff --git a/test/engine/test_execute.py b/test/engine/test_execute.py
index c1fe3140e..e99448a26 100644
--- a/test/engine/test_execute.py
+++ b/test/engine/test_execute.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 import collections.abc as collections_abc
 from contextlib import contextmanager
 from contextlib import nullcontext
@@ -507,7 +505,7 @@ class ExecuteTest(fixtures.TablesTest):
     def test_stmt_exception_bytestring_utf8(self):
         # uncommon case for Py3K, bytestring object passed
         # as the error message
-        message = "some message méil".encode("utf-8")
+        message = "some message méil".encode()
 
         err = tsa.exc.SQLAlchemyError(message)
         eq_(str(err), "some message méil")
@@ -537,7 +535,7 @@ class ExecuteTest(fixtures.TablesTest):
         eq_(str(err), "('some message', 206)")
 
     def test_stmt_exception_str_multi_args_bytestring(self):
-        message = "some message méil".encode("utf-8")
+        message = "some message méil".encode()
 
         err = tsa.exc.SQLAlchemyError(message, 206)
         eq_(str(err), str((message, 206)))
@@ -2500,60 +2498,52 @@ class EngineEventsTest(fixtures.TestBase):
         eq_(
             canary,
             [
-                ("begin", set(["conn"])),
+                ("begin", {"conn"}),
                 (
                     "execute",
-                    set(
-                        [
-                            "conn",
-                            "clauseelement",
-                            "multiparams",
-                            "params",
-                            "execution_options",
-                        ]
-                    ),
+                    {
+                        "conn",
+                        "clauseelement",
+                        "multiparams",
+                        "params",
+                        "execution_options",
+                    },
                 ),
                 (
                     "cursor_execute",
-                    set(
-                        [
-                            "conn",
-                            "cursor",
-                            "executemany",
-                            "statement",
-                            "parameters",
-                            "context",
-                        ]
-                    ),
+                    {
+                        "conn",
+                        "cursor",
+                        "executemany",
+                        "statement",
+                        "parameters",
+                        "context",
+                    },
                 ),
-                ("rollback", set(["conn"])),
-                ("begin", set(["conn"])),
+                ("rollback", {"conn"}),
+                ("begin", {"conn"}),
                 (
                     "execute",
-                    set(
-                        [
-                            "conn",
-                            "clauseelement",
-                            "multiparams",
-                            "params",
-                            "execution_options",
-                        ]
-                    ),
+                    {
+                        "conn",
+                        "clauseelement",
+                        "multiparams",
+                        "params",
+                        "execution_options",
+                    },
                 ),
                 (
                     "cursor_execute",
-                    set(
-                        [
-                            "conn",
-                            "cursor",
-                            "executemany",
-                            "statement",
-                            "parameters",
-                            "context",
-                        ]
-                    ),
+                    {
+                        "conn",
+                        "cursor",
+                        "executemany",
+                        "statement",
+                        "parameters",
+                        "context",
+                    },
                 ),
-                ("commit", set(["conn"])),
+                ("commit", {"conn"}),
             ],
         )
 
@@ -3383,11 +3373,11 @@ class OnConnectTest(fixtures.TestBase):
 
         class SomeDialect(cls_):
             def initialize(self, connection):
-                super(SomeDialect, self).initialize(connection)
+                super().initialize(connection)
                 m1.initialize(connection)
 
             def on_connect(self):
-                oc = super(SomeDialect, self).on_connect()
+                oc = super().on_connect()
 
                 def my_on_connect(conn):
                     if oc:
@@ -3456,11 +3446,11 @@ class OnConnectTest(fixtures.TestBase):
             supports_statement_cache = True
 
             def initialize(self, connection):
-                super(SomeDialect, self).initialize(connection)
+                super().initialize(connection)
                 m1.append("initialize")
 
             def on_connect(self):
-                oc = super(SomeDialect, self).on_connect()
+                oc = super().on_connect()
 
                 def my_on_connect(conn):
                     if oc:
diff --git a/test/engine/test_pool.py b/test/engine/test_pool.py
index 9d9c3a429..f267eac77 100644
--- a/test/engine/test_pool.py
+++ b/test/engine/test_pool.py
@@ -1410,8 +1410,8 @@ class QueuePoolTest(PoolTestBase):
         # two pooled connections unclosed.
 
         eq_(
-            set([c.close.call_count for c in strong_refs]),
-            set([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0]),
+            {c.close.call_count for c in strong_refs},
+            {1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0},
         )
 
     def test_recycle(self):
@@ -1693,7 +1693,7 @@ class QueuePoolTest(PoolTestBase):
         class TrackQueuePool(pool.QueuePool):
             def __init__(self, *arg, **kw):
                 pools.append(self)
-                super(TrackQueuePool, self).__init__(*arg, **kw)
+                super().__init__(*arg, **kw)
 
         def creator():
             return slow_closing_connection.connect()
diff --git a/test/engine/test_reflection.py b/test/engine/test_reflection.py
index 2aefecaef..81b85df08 100644
--- a/test/engine/test_reflection.py
+++ b/test/engine/test_reflection.py
@@ -136,10 +136,10 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
         )
         meta.create_all(connection)
         meta2 = MetaData()
-        t1r, t2r, t3r = [
+        t1r, t2r, t3r = (
             Table(x, meta2, autoload_with=connection)
             for x in ("t1", "t2", "t3")
-        ]
+        )
         assert t1r.c.t2id.references(t2r.c.id)
         assert t1r.c.t3id.references(t3r.c.id)
 
@@ -283,7 +283,7 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
             extend_existing=True,
             autoload_with=connection,
         )
-        eq_(set(t2.columns.keys()), set(["x", "y", "z", "q", "id"]))
+        eq_(set(t2.columns.keys()), {"x", "y", "z", "q", "id"})
 
         # this has been the actual behavior, the cols are added together,
         # however the test wasn't checking this correctly
@@ -302,7 +302,7 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
             extend_existing=False,
             autoload_with=connection,
         )
-        eq_(set(t3.columns.keys()), set(["z"]))
+        eq_(set(t3.columns.keys()), {"z"})
 
         m4 = MetaData()
         old_z = Column("z", String, primary_key=True)
@@ -318,7 +318,7 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
             autoload_replace=False,
             autoload_with=connection,
         )
-        eq_(set(t4.columns.keys()), set(["x", "y", "z", "q", "id"]))
+        eq_(set(t4.columns.keys()), {"x", "y", "z", "q", "id"})
         eq_(list(t4.primary_key.columns), [t4.c.z, t4.c.id])
         assert t4.c.z is old_z
         assert t4.c.y is old_y
@@ -1117,11 +1117,11 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
 
         m2 = MetaData()
         m2.reflect(connection, only=["rt_a", "rt_b"])
-        eq_(set(m2.tables.keys()), set(["rt_a", "rt_b"]))
+        eq_(set(m2.tables.keys()), {"rt_a", "rt_b"})
 
         m3 = MetaData()
         m3.reflect(connection, only=lambda name, meta: name == "rt_c")
-        eq_(set(m3.tables.keys()), set(["rt_c"]))
+        eq_(set(m3.tables.keys()), {"rt_c"})
 
         m4 = MetaData()
 
@@ -1155,7 +1155,7 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
         m8_e2 = MetaData()
         rt_c = Table("rt_c", m8_e2)
         m8_e2.reflect(connection, extend_existing=True, only=["rt_a", "rt_c"])
-        eq_(set(m8_e2.tables.keys()), set(["rt_a", "rt_c"]))
+        eq_(set(m8_e2.tables.keys()), {"rt_a", "rt_c"})
         eq_(rt_c.c.keys(), ["id"])
 
         baseline.drop_all(connection)
@@ -1212,16 +1212,16 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
         # Make sure indexes are in the order we expect them in
         tmp = [(idx.name, idx) for idx in t2.indexes]
         tmp.sort()
-        r1, r2, r3 = [idx[1] for idx in tmp]
+        r1, r2, r3 = (idx[1] for idx in tmp)
 
         assert r1.name == "idx1"
         assert r2.name == "idx2"
         assert r1.unique == True  # noqa
         assert r2.unique == False  # noqa
         assert r3.unique == False  # noqa
-        assert set([t2.c.id]) == set(r1.columns)
-        assert set([t2.c.name, t2.c.id]) == set(r2.columns)
-        assert set([t2.c.name]) == set(r3.columns)
+        assert {t2.c.id} == set(r1.columns)
+        assert {t2.c.name, t2.c.id} == set(r2.columns)
+        assert {t2.c.name} == set(r3.columns)
 
     @testing.requires.comment_reflection
     def test_comment_reflection(self, connection, metadata):
@@ -1350,23 +1350,19 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
             m2 = MetaData()
 
             m2.reflect(connection, views=False)
-            eq_(
-                set(m2.tables), set(["users", "email_addresses", "dingalings"])
-            )
+            eq_(set(m2.tables), {"users", "email_addresses", "dingalings"})
 
             m2 = MetaData()
             m2.reflect(connection, views=True)
             eq_(
                 set(m2.tables),
-                set(
-                    [
-                        "email_addresses_v",
-                        "users_v",
-                        "users",
-                        "dingalings",
-                        "email_addresses",
-                    ]
-                ),
+                {
+                    "email_addresses_v",
+                    "users_v",
+                    "users",
+                    "dingalings",
+                    "email_addresses",
+                },
             )
         finally:
             _drop_views(connection)
@@ -1537,7 +1533,7 @@ class SchemaManipulationTest(fixtures.TestBase):
         addresses.append_constraint(fk)
         addresses.append_constraint(fk)
         assert len(addresses.c.user_id.foreign_keys) == 1
-        assert addresses.constraints == set([addresses.primary_key, fk])
+        assert addresses.constraints == {addresses.primary_key, fk}
 
 
 class UnicodeReflectionTest(fixtures.TablesTest):
@@ -1546,7 +1542,7 @@ class UnicodeReflectionTest(fixtures.TablesTest):
     @classmethod
     def define_tables(cls, metadata):
 
-        no_multibyte_period = set([("plain", "col_plain", "ix_plain")])
+        no_multibyte_period = {("plain", "col_plain", "ix_plain")}
         no_has_table = [
             (
                 "no_has_table_1",
@@ -1628,7 +1624,7 @@ class UnicodeReflectionTest(fixtures.TablesTest):
         # (others?) expect non-unicode strings in result sets/bind
         # params
 
-        names = set([rec[0] for rec in self.names])
+        names = {rec[0] for rec in self.names}
 
         reflected = set(inspect(connection).get_table_names())
 
@@ -1639,7 +1635,7 @@ class UnicodeReflectionTest(fixtures.TablesTest):
             # explicitly NFC).  Maybe this database normalizes NFD
             # on reflection.
 
-            nfc = set([unicodedata.normalize("NFC", n) for n in names])
+            nfc = {unicodedata.normalize("NFC", n) for n in names}
             self.assert_(nfc == names)
 
             # Yep.  But still ensure that bulk reflection and
@@ -1653,9 +1649,7 @@ class UnicodeReflectionTest(fixtures.TablesTest):
     @testing.requires.unicode_connections
     def test_get_names(self, connection):
         inspector = inspect(connection)
-        names = dict(
-            (tname, (cname, ixname)) for tname, cname, ixname in self.names
-        )
+        names = {tname: (cname, ixname) for tname, cname, ixname in self.names}
         for tname in inspector.get_table_names():
             assert tname in names
             eq_(
@@ -1710,12 +1704,10 @@ class SchemaTest(fixtures.TestBase):
 
         eq_(
             set(meta2.tables),
-            set(
-                [
-                    "some_other_table",
-                    "%s.some_table" % testing.config.test_schema,
-                ]
-            ),
+            {
+                "some_other_table",
+                "%s.some_table" % testing.config.test_schema,
+            },
         )
 
     @testing.requires.schemas
@@ -1806,13 +1798,11 @@ class SchemaTest(fixtures.TestBase):
         m2.reflect(connection)
         eq_(
             set(m2.tables),
-            set(
-                [
-                    "%s.dingalings" % testing.config.test_schema,
-                    "%s.users" % testing.config.test_schema,
-                    "%s.email_addresses" % testing.config.test_schema,
-                ]
-            ),
+            {
+                "%s.dingalings" % testing.config.test_schema,
+                "%s.users" % testing.config.test_schema,
+                "%s.email_addresses" % testing.config.test_schema,
+            },
         )
 
     @testing.requires.schemas
@@ -1837,8 +1827,8 @@ class SchemaTest(fixtures.TestBase):
         m3.reflect(connection, schema=testing.config.test_schema)
 
         eq_(
-            set((t.name, t.schema) for t in m2.tables.values()),
-            set((t.name, t.schema) for t in m3.tables.values()),
+            {(t.name, t.schema) for t in m2.tables.values()},
+            {(t.name, t.schema) for t in m3.tables.values()},
         )
 
 
@@ -1993,7 +1983,7 @@ class CaseSensitiveTest(fixtures.TablesTest):
     @testing.fails_if(testing.requires._has_mysql_on_windows)
     def test_table_names(self, connection):
         x = inspect(connection).get_table_names()
-        assert set(["SomeTable", "SomeOtherTable"]).issubset(x)
+        assert {"SomeTable", "SomeOtherTable"}.issubset(x)
 
     def test_reflect_exact_name(self, connection):
         m = MetaData()
@@ -2068,7 +2058,7 @@ class ColumnEventsTest(fixtures.RemovesEvents, fixtures.TablesTest):
     def test_override_key(self, connection):
         def assertions(table):
             eq_(table.c.YXZ.name, "x")
-            eq_(set(table.primary_key), set([table.c.YXZ]))
+            eq_(set(table.primary_key), {table.c.YXZ})
 
         self._do_test(connection, "x", {"key": "YXZ"}, assertions)
 
@@ -2357,7 +2347,7 @@ class IncludeColsFksTest(AssertsCompiledSQL, fixtures.TestBase):
         eq_([c.name for c in b2.c], ["x", "q", "p"])
 
         # no FK, whether or not resolve_fks was called
-        eq_(b2.constraints, set((b2.primary_key,)))
+        eq_(b2.constraints, {b2.primary_key})
 
         b2a = b2.alias()
         eq_([c.name for c in b2a.c], ["x", "q", "p"])