- flake8 refactor - test_ormflake8_12

A full rewrite of all imports and pep8 formatting using zimports, black,
commits are broken into sections.

Directories included in this commit:

    test/orm/ test/ext/

did not fully merge this one, needs to be done from scratch

Change-Id: I22b42d81bbc35c3a4a8ad4e48dbc78c363cdd4e3
(cherry picked from commit 380f75c051314e615694cdb9186e8ac7de128131)

31 files changed, 544 insertions, 164 deletions

diff --git a/test/orm/_fixtures.py b/test/orm/_fixtures.py
index b8bb06ad2..1c6285615 100644
--- a/test/orm/_fixtures.py
+++ b/test/orm/_fixtures.py
@@ -55,7 +55,26 @@ class FixtureTest(fixtures.MappedTest):
 
     @classmethod
     def _setup_stock_mapping(cls):
-        Node, composite_pk_table, users, Keyword, items, Dingaling, order_items, item_keywords, Item, User, dingalings, Address, keywords, CompositePk, nodes, Order, orders, addresses = (
+        (
+            Node,
+            composite_pk_table,
+            users,
+            Keyword,
+            items,
+            Dingaling,
+            order_items,
+            item_keywords,
+            Item,
+            User,
+            dingalings,
+            Address,
+            keywords,
+            CompositePk,
+            nodes,
+            Order,
+            orders,
+            addresses,
+        ) = (
             cls.classes.Node,
             cls.tables.composite_pk_table,
             cls.tables.users,
diff --git a/test/orm/inheritance/test_assorted_poly.py b/test/orm/inheritance/test_assorted_poly.py
index 83044ef51..b47100647 100644
--- a/test/orm/inheritance/test_assorted_poly.py
+++ b/test/orm/inheritance/test_assorted_poly.py
@@ -506,8 +506,8 @@ def _generate_test(jointype="join1", usedata=False):
 
 for jointype in ["join1", "join2", "join3", "join4"]:
     for data in (True, False):
-        func = _generate_test(jointype, data)
-        setattr(RelationshipTest3, func.__name__, func)
+        _fn = _generate_test(jointype, data)
+        setattr(RelationshipTest3, _fn.__name__, _fn)
 del func
 
 
@@ -1502,7 +1502,8 @@ class MultiLevelTest(fixtures.MappedTest):
 class ManyToManyPolyTest(fixtures.MappedTest):
     @classmethod
     def define_tables(cls, metadata):
-        global base_item_table, item_table, base_item_collection_table, collection_table
+        global base_item_table, item_table
+        global base_item_collection_table, collection_table
         base_item_table = Table(
             "base_item",
             metadata,
diff --git a/test/orm/inheritance/test_basic.py b/test/orm/inheritance/test_basic.py
index 81eb89f91..403afb6e1 100644
--- a/test/orm/inheritance/test_basic.py
+++ b/test/orm/inheritance/test_basic.py
@@ -1049,7 +1049,8 @@ class M2OUseGetTest(fixtures.MappedTest):
                 # the 'primaryjoin' looks just like "Sub"'s "get" clause
                 # (based on the Base id), and foreign_keys since that join
                 # condition doesn't actually have any fks in it
-                # 'sub':relationship(Sub, primaryjoin=base.c.id==related.c.sub_id,
+                # 'sub':relationship(Sub,
+                # primaryjoin=base.c.id==related.c.sub_id,
                 # foreign_keys=related.c.sub_id)
                 # now we can use this:
                 "sub": relationship(Sub)
@@ -2018,7 +2019,7 @@ class DistinctPKTest(fixtures.MappedTest):
             r"On mapper Mapper\|Employee\|employees, "
             "primary key column 'persons.id' is being "
             "combined with distinct primary key column 'employees.eid' "
-            "in attribute 'id'.  Use explicit properties to give "
+            "in attribute 'id'. Use explicit properties to give "
             "each column its own mapped attribute name.",
             self._do_test,
             True,
diff --git a/test/orm/inheritance/test_concrete.py b/test/orm/inheritance/test_concrete.py
index aec3fee7d..3395e372c 100644
--- a/test/orm/inheritance/test_concrete.py
+++ b/test/orm/inheritance/test_concrete.py
@@ -86,7 +86,8 @@ class Company(object):
 class ConcreteTest(fixtures.MappedTest):
     @classmethod
     def define_tables(cls, metadata):
-        global managers_table, engineers_table, hackers_table, companies, employees_table
+        global managers_table, engineers_table, hackers_table
+        global companies, employees_table
         companies = Table(
             "companies",
             metadata,
diff --git a/test/orm/inheritance/test_magazine.py b/test/orm/inheritance/test_magazine.py
index 6329540b9..27f5e71ce 100644
--- a/test/orm/inheritance/test_magazine.py
+++ b/test/orm/inheritance/test_magazine.py
@@ -1,11 +1,7 @@
 from sqlalchemy import CHAR
-from sqlalchemy import Column
 from sqlalchemy import ForeignKey
 from sqlalchemy import Integer
-from sqlalchemy import join
-from sqlalchemy import outerjoin
 from sqlalchemy import String
-from sqlalchemy import Table
 from sqlalchemy import Text
 from sqlalchemy.orm import backref
 from sqlalchemy.orm import create_session
@@ -116,9 +112,7 @@ class ClassifiedPage(MagazinePage):
 class MagazineTest(fixtures.MappedTest):
     @classmethod
     def define_tables(cls, metadata):
-        global publication_table, issue_table, location_table, location_name_table, magazine_table, page_table, magazine_page_table, classified_page_table, page_size_table
-
-        publication_table = Table(
+        Table(
             "publication",
             metadata,
             Column(
@@ -126,7 +120,7 @@ class MagazineTest(fixtures.MappedTest):
             ),
             Column("name", String(45), default=""),
         )
-        issue_table = Table(
+        Table(
             "issue",
             metadata,
             Column(
@@ -135,7 +129,7 @@ class MagazineTest(fixtures.MappedTest):
             Column("publication_id", Integer, ForeignKey("publication.id")),
             Column("issue", Integer),
         )
-        location_table = Table(
+        Table(
             "location",
             metadata,
             Column(
@@ -147,7 +141,7 @@ class MagazineTest(fixtures.MappedTest):
                 "location_name_id", Integer, ForeignKey("location_name.id")
             ),
         )
-        location_name_table = Table(
+        Table(
             "location_name",
             metadata,
             Column(
@@ -155,7 +149,7 @@ class MagazineTest(fixtures.MappedTest):
             ),
             Column("name", String(45), default=""),
         )
-        magazine_table = Table(
+        Table(
             "magazine",
             metadata,
             Column(
@@ -164,7 +158,7 @@ class MagazineTest(fixtures.MappedTest):
             Column("location_id", Integer, ForeignKey("location.id")),
             Column("page_size_id", Integer, ForeignKey("page_size.id")),
         )
-        page_table = Table(
+        Table(
             "page",
             metadata,
             Column(
@@ -173,7 +167,7 @@ class MagazineTest(fixtures.MappedTest):
             Column("page_no", Integer),
             Column("type", CHAR(1), default="p"),
         )
-        magazine_page_table = Table(
+        Table(
             "magazine_page",
             metadata,
             Column(
@@ -182,7 +176,7 @@ class MagazineTest(fixtures.MappedTest):
             Column("magazine_id", Integer, ForeignKey("magazine.id")),
             Column("orders", Text, default=""),
         )
-        classified_page_table = Table(
+        Table(
             "classified_page",
             metadata,
             Column(
@@ -193,7 +187,7 @@ class MagazineTest(fixtures.MappedTest):
             ),
             Column("titles", String(45), default=""),
         )
-        page_size_table = Table(
+        Table(
             "page_size",
             metadata,
             Column(
@@ -207,11 +201,11 @@ class MagazineTest(fixtures.MappedTest):
 
 def _generate_round_trip_test(use_unions=False, use_joins=False):
     def test_roundtrip(self):
-        publication_mapper = mapper(Publication, publication_table)
+        publication_mapper = mapper(Publication, self.tables.publication)
 
         issue_mapper = mapper(
             Issue,
-            issue_table,
+            self.tables.issue,
             properties={
                 "publication": relationship(
                     Publication,
@@ -220,11 +214,11 @@ def _generate_round_trip_test(use_unions=False, use_joins=False):
             },
         )
 
-        location_name_mapper = mapper(LocationName, location_name_table)
+        location_name_mapper = mapper(LocationName, self.tables.location_name)
 
         location_mapper = mapper(
             Location,
-            location_table,
+            self.tables.location,
             properties={
                 "issue": relationship(
                     Issue,
@@ -238,11 +232,11 @@ def _generate_round_trip_test(use_unions=False, use_joins=False):
             },
         )
 
-        page_size_mapper = mapper(PageSize, page_size_table)
+        page_size_mapper = mapper(PageSize, self.tables.page_size)
 
         magazine_mapper = mapper(
             Magazine,
-            magazine_table,
+            self.tables.magazine,
             properties={
                 "location": relationship(
                     Location, backref=backref("magazine", uselist=False)
@@ -254,47 +248,49 @@ def _generate_round_trip_test(use_unions=False, use_joins=False):
         if use_unions:
             page_join = polymorphic_union(
                 {
-                    "m": page_table.join(magazine_page_table),
-                    "c": page_table.join(magazine_page_table).join(
-                        classified_page_table
+                    "m": self.tables.page.join(self.tables.magazine_page),
+                    "c": self.tables.page.join(self.tables.magazine_page).join(
+                        self.tables.classified_page
+                    ),
+                    "p": self.tables.page.select(
+                        self.tables.page.c.type == "p"
                     ),
-                    "p": page_table.select(page_table.c.type == "p"),
                 },
                 None,
                 "page_join",
             )
             page_mapper = mapper(
                 Page,
-                page_table,
+                self.tables.page,
                 with_polymorphic=("*", page_join),
                 polymorphic_on=page_join.c.type,
                 polymorphic_identity="p",
             )
         elif use_joins:
-            page_join = page_table.outerjoin(magazine_page_table).outerjoin(
-                classified_page_table
-            )
+            page_join = self.tables.page.outerjoin(
+                self.tables.magazine_page
+            ).outerjoin(self.tables.classified_page)
             page_mapper = mapper(
                 Page,
-                page_table,
+                self.tables.page,
                 with_polymorphic=("*", page_join),
-                polymorphic_on=page_table.c.type,
+                polymorphic_on=self.tables.page.c.type,
                 polymorphic_identity="p",
             )
         else:
             page_mapper = mapper(
                 Page,
-                page_table,
-                polymorphic_on=page_table.c.type,
+                self.tables.page,
+                polymorphic_on=self.tables.page.c.type,
                 polymorphic_identity="p",
             )
 
         if use_unions:
             magazine_join = polymorphic_union(
                 {
-                    "m": page_table.join(magazine_page_table),
-                    "c": page_table.join(magazine_page_table).join(
-                        classified_page_table
+                    "m": self.tables.page.join(self.tables.magazine_page),
+                    "c": self.tables.page.join(self.tables.magazine_page).join(
+                        self.tables.classified_page
                     ),
                 },
                 None,
@@ -302,7 +298,7 @@ def _generate_round_trip_test(use_unions=False, use_joins=False):
             )
             magazine_page_mapper = mapper(
                 MagazinePage,
-                magazine_page_table,
+                self.tables.magazine_page,
                 with_polymorphic=("*", magazine_join),
                 inherits=page_mapper,
                 polymorphic_identity="m",
@@ -316,12 +312,12 @@ def _generate_round_trip_test(use_unions=False, use_joins=False):
                 },
             )
         elif use_joins:
-            magazine_join = page_table.join(magazine_page_table).outerjoin(
-                classified_page_table
-            )
+            magazine_join = self.tables.page.join(
+                self.tables.magazine_page
+            ).outerjoin(self.tables.classified_page)
             magazine_page_mapper = mapper(
                 MagazinePage,
-                magazine_page_table,
+                self.tables.magazine_page,
                 with_polymorphic=("*", magazine_join),
                 inherits=page_mapper,
                 polymorphic_identity="m",
@@ -329,7 +325,7 @@ def _generate_round_trip_test(use_unions=False, use_joins=False):
                     "magazine": relationship(
                         Magazine,
                         backref=backref(
-                            "pages", order_by=page_table.c.page_no
+                            "pages", order_by=self.tables.page.c.page_no
                         ),
                     )
                 },
@@ -337,14 +333,14 @@ def _generate_round_trip_test(use_unions=False, use_joins=False):
         else:
             magazine_page_mapper = mapper(
                 MagazinePage,
-                magazine_page_table,
+                self.tables.magazine_page,
                 inherits=page_mapper,
                 polymorphic_identity="m",
                 properties={
                     "magazine": relationship(
                         Magazine,
                         backref=backref(
-                            "pages", order_by=page_table.c.page_no
+                            "pages", order_by=self.tables.page.c.page_no
                         ),
                     )
                 },
@@ -352,10 +348,10 @@ def _generate_round_trip_test(use_unions=False, use_joins=False):
 
         classified_page_mapper = mapper(
             ClassifiedPage,
-            classified_page_table,
+            self.tables.classified_page,
             inherits=magazine_page_mapper,
             polymorphic_identity="c",
-            primary_key=[page_table.c.id],
+            primary_key=[self.tables.page.c.id],
         )
 
         session = create_session()
diff --git a/test/orm/inheritance/test_poly_loading.py b/test/orm/inheritance/test_poly_loading.py
index 2a081bf7e..70f869809 100644
--- a/test/orm/inheritance/test_poly_loading.py
+++ b/test/orm/inheritance/test_poly_loading.py
@@ -104,9 +104,11 @@ class BaseAndSubFixture(object):
             AllOf(
                 EachOf(
                     CompiledSQL(
-                        "SELECT asub.id AS asub_id, a.id AS a_id, a.type AS a_type, "
+                        "SELECT asub.id AS asub_id, a.id AS a_id, "
+                        "a.type AS a_type, "
                         "asub.asubdata AS asub_asubdata FROM a JOIN asub "
-                        "ON a.id = asub.id WHERE a.id IN ([EXPANDING_primary_keys]) "
+                        "ON a.id = asub.id "
+                        "WHERE a.id IN ([EXPANDING_primary_keys]) "
                         "ORDER BY a.id",
                         {"primary_keys": [2]},
                     ),
diff --git a/test/orm/inheritance/test_poly_persistence.py b/test/orm/inheritance/test_poly_persistence.py
index 65b8ff750..c8d22e293 100644
--- a/test/orm/inheritance/test_poly_persistence.py
+++ b/test/orm/inheritance/test_poly_persistence.py
@@ -517,19 +517,19 @@ def _generate_round_trip_test(
 
 for lazy_relationship in [True, False]:
     for redefine_colprop in [True, False]:
-        for with_polymorphic in ["unions", "joins", "auto", "none"]:
-            if with_polymorphic == "unions":
+        for with_polymorphic_ in ["unions", "joins", "auto", "none"]:
+            if with_polymorphic_ == "unions":
                 for include_base in [True, False]:
                     _generate_round_trip_test(
                         include_base,
                         lazy_relationship,
                         redefine_colprop,
-                        with_polymorphic,
+                        with_polymorphic_,
                     )
             else:
                 _generate_round_trip_test(
                     False,
                     lazy_relationship,
                     redefine_colprop,
-                    with_polymorphic,
+                    with_polymorphic_,
                 )
diff --git a/test/orm/inheritance/test_polymorphic_rel.py b/test/orm/inheritance/test_polymorphic_rel.py
index 96f300b88..500d90cfd 100644
--- a/test/orm/inheritance/test_polymorphic_rel.py
+++ b/test/orm/inheritance/test_polymorphic_rel.py
@@ -1635,10 +1635,10 @@ class _PolymorphicTestBase(object):
     def test_correlation_one(self):
         sess = create_session()
 
-        # unfortunately this pattern can't yet work for PolymorphicAliased
-        # and PolymorphicUnions, because the subquery does not compile
-        # out including the polymorphic selectable; only if Person is in
-        # the query() list does that happen.
+        # this for a long time did not work with PolymorphicAliased and
+        # PolymorphicUnions, which was due to the no_replacement_traverse
+        # annotation added to query.statement which then went into as_scalar().
+        # this is removed as of :ticket:`4304` so now works.
         eq_(
             sess.query(Person.name)
             .filter(
diff --git a/test/orm/inheritance/test_single.py b/test/orm/inheritance/test_single.py
index b1eb7bb8d..2db1cfb50 100644
--- a/test/orm/inheritance/test_single.py
+++ b/test/orm/inheritance/test_single.py
@@ -633,7 +633,15 @@ class RelationshipToSingleTest(
             pass
 
     def test_of_type(self):
-        JuniorEngineer, Company, companies, Manager, Employee, employees, Engineer = (
+        (
+            JuniorEngineer,
+            Company,
+            companies,
+            Manager,
+            Employee,
+            employees,
+            Engineer,
+        ) = (
             self.classes.JuniorEngineer,
             self.classes.Company,
             self.tables.companies,
@@ -1044,7 +1052,15 @@ class RelationshipToSingleTest(
             )
 
     def test_relationship_to_subclass(self):
-        JuniorEngineer, Company, companies, Manager, Employee, employees, Engineer = (
+        (
+            JuniorEngineer,
+            Company,
+            companies,
+            Manager,
+            Employee,
+            employees,
+            Engineer,
+        ) = (
             self.classes.JuniorEngineer,
             self.classes.Company,
             self.tables.companies,
diff --git a/test/orm/test_assorted_eager.py b/test/orm/test_assorted_eager.py
index ef428d008..3e49623fc 100644
--- a/test/orm/test_assorted_eager.py
+++ b/test/orm/test_assorted_eager.py
@@ -713,7 +713,16 @@ class EagerTest5(fixtures.MappedTest):
                 self.comment = comment
 
     def test_basic(self):
-        Comment, Derived, derived, comments, DerivedII, Base, base, derivedII = (
+        (
+            Comment,
+            Derived,
+            derived,
+            comments,
+            DerivedII,
+            Base,
+            base,
+            derivedII,
+        ) = (
             self.classes.Comment,
             self.classes.Derived,
             self.tables.derived,
@@ -843,7 +852,16 @@ class EagerTest6(fixtures.MappedTest):
             pass
 
     def test_one(self):
-        Part, inherited_part, design_types, DesignType, parts, design, Design, InheritedPart = (
+        (
+            Part,
+            inherited_part,
+            design_types,
+            DesignType,
+            parts,
+            design,
+            Design,
+            InheritedPart,
+        ) = (
             self.classes.Part,
             self.tables.inherited_part,
             self.tables.design_types,
diff --git a/test/orm/test_attributes.py b/test/orm/test_attributes.py
index f6f8c7d65..33eb36c8c 100644
--- a/test/orm/test_attributes.py
+++ b/test/orm/test_attributes.py
@@ -357,7 +357,6 @@ class AttributesTest(fixtures.ORMTest):
             "'Foo.bars' - parent object of type <Foo> "
             "has been garbage collected.",
             lambda: Foo().bars.append(Bar()),
-        )
 
     def test_deferred(self):
         class Foo(object):
@@ -3497,11 +3496,11 @@ class ListenerTest(fixtures.ORMTest):
                 classes[2], "attrib", uselist=False, useobject=False
             )
 
-        def set(state, value, oldvalue, initiator):
+        def set_(state, value, oldvalue, initiator):
             canary.append(value)
 
         def events_a():
-            event.listen(classes[0].attrib, "set", set, propagate=True)
+            event.listen(classes[0].attrib, "set", set_, propagate=True)
 
         def teardown():
             classes[:] = [None, None, None]
diff --git a/test/orm/test_cascade.py b/test/orm/test_cascade.py
index bc0f7211a..1cd9d344f 100644
--- a/test/orm/test_cascade.py
+++ b/test/orm/test_cascade.py
@@ -226,7 +226,16 @@ class O2MCascadeDeleteOrphanTest(fixtures.MappedTest):
 
     @classmethod
     def setup_mappers(cls):
-        users, Dingaling, Order, User, dingalings, Address, orders, addresses = (
+        (
+            users,
+            Dingaling,
+            Order,
+            User,
+            dingalings,
+            Address,
+            orders,
+            addresses,
+        ) = (
             cls.tables.users,
             cls.classes.Dingaling,
             cls.classes.Order,
@@ -2145,8 +2154,8 @@ class M2MCascadeTest(fixtures.MappedTest):
             A,
             a,
             properties={
-                # if no backref here, delete-orphan failed until [ticket:427] was
-                # fixed
+                # if no backref here, delete-orphan failed until #
+                # [ticket:427] was fixed
                 "bs": relationship(
                     B,
                     secondary=atob,
@@ -3821,7 +3830,14 @@ class SubclassCascadeTest(fixtures.DeclarativeMappedTest):
             __mapper_args__ = {"polymorphic_identity": "java_language"}
 
     def test_cascade_iterator_polymorphic(self):
-        Company, Employee, Engineer, Language, JavaLanguage, MavenBuild = self.classes(
+        (
+            Company,
+            Employee,
+            Engineer,
+            Language,
+            JavaLanguage,
+            MavenBuild,
+        ) = self.classes(
             "Company",
             "Employee",
             "Engineer",
@@ -3854,7 +3870,14 @@ class SubclassCascadeTest(fixtures.DeclarativeMappedTest):
         eq_(set([rec[0] for rec in it]), set([maven_build, lang]))
 
     def test_delete_orphan_round_trip(self):
-        Company, Employee, Engineer, Language, JavaLanguage, MavenBuild = self.classes(
+        (
+            Company,
+            Employee,
+            Engineer,
+            Language,
+            JavaLanguage,
+            MavenBuild,
+        ) = self.classes(
             "Company",
             "Employee",
             "Engineer",
diff --git a/test/orm/test_collection.py b/test/orm/test_collection.py
index 3a908d2d9..f33df5dc3 100644
--- a/test/orm/test_collection.py
+++ b/test/orm/test_collection.py
@@ -78,8 +78,8 @@ class CollectionsTest(fixtures.ORMTest):
 
     @classmethod
     def dictable_entity(cls, a=None, b=None, c=None):
-        id = cls._entity_id = cls._entity_id + 1
-        return cls.Entity(a or str(id), b or "value %s" % id, c)
+        id_ = cls._entity_id = cls._entity_id + 1
+        return cls.Entity(a or str(id_), b or "value %s" % id, c)
 
     def _test_adapter(self, typecallable, creator=None, to_set=None):
         if creator is None:
diff --git a/test/orm/test_default_strategies.py b/test/orm/test_default_strategies.py
index 53de867c7..53309b282 100644
--- a/test/orm/test_default_strategies.py
+++ b/test/orm/test_default_strategies.py
@@ -39,7 +39,20 @@ class DefaultStrategyOptionsTest(_fixtures.FixtureTest):
         self.assert_sql_count(testing.db, go, 0)
 
     def _downgrade_fixture(self):
-        users, Keyword, items, order_items, orders, Item, User, Address, keywords, item_keywords, Order, addresses = (
+        (
+            users,
+            Keyword,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            keywords,
+            item_keywords,
+            Order,
+            addresses,
+        ) = (
             self.tables.users,
             self.classes.Keyword,
             self.tables.items,
@@ -100,7 +113,20 @@ class DefaultStrategyOptionsTest(_fixtures.FixtureTest):
         return create_session()
 
     def _upgrade_fixture(self):
-        users, Keyword, items, order_items, orders, Item, User, Address, keywords, item_keywords, Order, addresses = (
+        (
+            users,
+            Keyword,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            keywords,
+            item_keywords,
+            Order,
+            addresses,
+        ) = (
             self.tables.users,
             self.classes.Keyword,
             self.tables.items,
diff --git a/test/orm/test_dynamic.py b/test/orm/test_dynamic.py
index 0cedd5604..b861a9fe5 100644
--- a/test/orm/test_dynamic.py
+++ b/test/orm/test_dynamic.py
@@ -742,16 +742,16 @@ class UOWTest(
             eq_(
                 testing.db.scalar(
                     select([func.count("*")]).where(
-                        addresses.c.user_id == None  # noqa
-                    )
+                        addresses.c.user_id == None
+                    )  # noqa
                 ),
                 6,
             )
             eq_(
                 testing.db.scalar(
                     select([func.count("*")]).where(
-                        addresses.c.user_id != None  # noqa
-                    )
+                        addresses.c.user_id != None
+                    )  # noqa
                 ),
                 0,
             )
diff --git a/test/orm/test_eager_relations.py b/test/orm/test_eager_relations.py
index 288c7a7c6..abcb597b9 100644
--- a/test/orm/test_eager_relations.py
+++ b/test/orm/test_eager_relations.py
@@ -493,7 +493,18 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
         self.assert_sql_count(testing.db, go, 1)
 
     def test_options_pathing(self):
-        users, Keyword, orders, items, order_items, Order, Item, User, keywords, item_keywords = (
+        (
+            users,
+            Keyword,
+            orders,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            keywords,
+            item_keywords,
+        ) = (
             self.tables.users,
             self.classes.Keyword,
             self.tables.orders,
@@ -795,7 +806,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
         """Eager loading with two relationships simultaneously,
         from the same table, using aliases."""
 
-        addresses, items, order_items, orders, Item, User, Address, Order, users = (
+        (
+            addresses,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            Order,
+            users,
+        ) = (
             self.tables.addresses,
             self.tables.items,
             self.tables.order_items,
@@ -940,7 +961,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
     def test_limit(self):
         """Limit operations combined with lazy-load relationships."""
 
-        users, items, order_items, orders, Item, User, Address, Order, addresses = (
+        (
+            users,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            Order,
+            addresses,
+        ) = (
             self.tables.users,
             self.tables.items,
             self.tables.order_items,
@@ -1075,7 +1106,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
         'wrapped' select statement resulting from the combination of
         eager loading and limit/offset clauses."""
 
-        addresses, items, order_items, orders, Item, User, Address, Order, users = (
+        (
+            addresses,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            Order,
+            users,
+        ) = (
             self.tables.addresses,
             self.tables.items,
             self.tables.order_items,
@@ -1306,7 +1347,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
         """test that the subquery wrapping only occurs with
         limit/offset and m2m or o2m joins present."""
 
-        users, items, order_items, Order, Item, User, Address, orders, addresses = (
+        (
+            users,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            Address,
+            orders,
+            addresses,
+        ) = (
             self.tables.users,
             self.tables.items,
             self.tables.order_items,
@@ -1740,7 +1791,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
         )
 
     def test_wide(self):
-        users, items, order_items, Order, Item, User, Address, orders, addresses = (
+        (
+            users,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            Address,
+            orders,
+            addresses,
+        ) = (
             self.tables.users,
             self.tables.items,
             self.tables.order_items,
@@ -2273,7 +2334,18 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
         # test eager join chaining to the "nested" join on the left,
         # a new feature as of [ticket:2369]
 
-        users, Keyword, orders, items, order_items, Order, Item, User, keywords, item_keywords = (
+        (
+            users,
+            Keyword,
+            orders,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            keywords,
+            item_keywords,
+        ) = (
             self.tables.users,
             self.classes.Keyword,
             self.tables.orders,
@@ -2290,8 +2362,8 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
             User,
             users,
             properties={
-                "orders": relationship(Order, backref="user")  # o2m, m2o
-            },
+                "orders": relationship(Order, backref="user")
+            },  # o2m, m2o
         )
         mapper(
             Order,
@@ -3476,7 +3548,17 @@ class AddEntityTest(_fixtures.FixtureTest):
         ]
 
     def test_mapper_configured(self):
-        users, items, order_items, Order, Item, User, Address, orders, addresses = (
+        (
+            users,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            Address,
+            orders,
+            addresses,
+        ) = (
             self.tables.users,
             self.tables.items,
             self.tables.order_items,
@@ -3526,7 +3608,17 @@ class AddEntityTest(_fixtures.FixtureTest):
         self.assert_sql_count(testing.db, go, 1)
 
     def test_options(self):
-        users, items, order_items, Order, Item, User, Address, orders, addresses = (
+        (
+            users,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            Address,
+            orders,
+            addresses,
+        ) = (
             self.tables.users,
             self.tables.items,
             self.tables.order_items,
@@ -4163,7 +4255,20 @@ class MixedEntitiesTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
 
     @classmethod
     def setup_mappers(cls):
-        users, Keyword, items, order_items, orders, Item, User, Address, keywords, Order, item_keywords, addresses = (
+        (
+            users,
+            Keyword,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            keywords,
+            Order,
+            item_keywords,
+            addresses,
+        ) = (
             cls.tables.users,
             cls.classes.Keyword,
             cls.tables.items,
diff --git a/test/orm/test_events.py b/test/orm/test_events.py
index 62395b137..46974c72e 100644
--- a/test/orm/test_events.py
+++ b/test/orm/test_events.py
@@ -565,7 +565,6 @@ class MapperEventsTest(_RemoveListeners, _fixtures.FixtureTest):
             canary.mock_calls,
         )
 
-
 class DeclarativeEventListenTest(
     _RemoveListeners, fixtures.DeclarativeMappedTest
 ):
diff --git a/test/orm/test_froms.py b/test/orm/test_froms.py
index 3460ae0c9..61217dd3f 100644
--- a/test/orm/test_froms.py
+++ b/test/orm/test_froms.py
@@ -51,7 +51,26 @@ class QueryTest(_fixtures.FixtureTest):
 
     @classmethod
     def setup_mappers(cls):
-        Node, composite_pk_table, users, Keyword, items, Dingaling, order_items, item_keywords, Item, User, dingalings, Address, keywords, CompositePk, nodes, Order, orders, addresses = (
+        (
+            Node,
+            composite_pk_table,
+            users,
+            Keyword,
+            items,
+            Dingaling,
+            order_items,
+            item_keywords,
+            Item,
+            User,
+            dingalings,
+            Address,
+            keywords,
+            CompositePk,
+            nodes,
+            Order,
+            orders,
+            addresses,
+        ) = (
             cls.classes.Node,
             cls.tables.composite_pk_table,
             cls.tables.users,
diff --git a/test/orm/test_joins.py b/test/orm/test_joins.py
index 1655fbfd4..4370882fe 100644
--- a/test/orm/test_joins.py
+++ b/test/orm/test_joins.py
@@ -51,7 +51,26 @@ class QueryTest(_fixtures.FixtureTest):
 
     @classmethod
     def setup_mappers(cls):
-        Node, composite_pk_table, users, Keyword, items, Dingaling, order_items, item_keywords, Item, User, dingalings, Address, keywords, CompositePk, nodes, Order, orders, addresses = (
+        (
+            Node,
+            composite_pk_table,
+            users,
+            Keyword,
+            items,
+            Dingaling,
+            order_items,
+            item_keywords,
+            Item,
+            User,
+            dingalings,
+            Address,
+            keywords,
+            CompositePk,
+            nodes,
+            Order,
+            orders,
+            addresses,
+        ) = (
             cls.classes.Node,
             cls.tables.composite_pk_table,
             cls.tables.users,
@@ -984,7 +1003,7 @@ class JoinTest(QueryTest, AssertsCompiledSQL):
     def test_overlapping_paths(self):
         User = self.classes.User
 
-        for aliased in (True, False):
+        for aliased_ in (True, False):
             # load a user who has an order that contains item id 3 and address
             # id 1 (order 3, owned by jack)
             result = (
@@ -1842,7 +1861,7 @@ class JoinTest(QueryTest, AssertsCompiledSQL):
     def test_reset_joinpoint(self):
         User = self.classes.User
 
-        for aliased in (True, False):
+        for aliased_ in (True, False):
             # load a user who has an order that contains item id 3 and address
             # id 1 (order 3, owned by jack)
             result = (
diff --git a/test/orm/test_lazy_relations.py b/test/orm/test_lazy_relations.py
index 8dd865a58..4d9e460f9 100644
--- a/test/orm/test_lazy_relations.py
+++ b/test/orm/test_lazy_relations.py
@@ -232,7 +232,17 @@ class LazyTest(_fixtures.FixtureTest):
     def test_limit(self):
         """test limit operations combined with lazy-load relationships."""
 
-        users, items, order_items, orders, Item, User, Address, Order, addresses = (
+        (
+            users,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            Order,
+            addresses,
+        ) = (
             self.tables.users,
             self.tables.items,
             self.tables.order_items,
@@ -276,7 +286,17 @@ class LazyTest(_fixtures.FixtureTest):
             assert self.static.user_all_result[1:3] == result
 
     def test_distinct(self):
-        users, items, order_items, orders, Item, User, Address, Order, addresses = (
+        (
+            users,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            Order,
+            addresses,
+        ) = (
             self.tables.users,
             self.tables.items,
             self.tables.order_items,
diff --git a/test/orm/test_load_on_fks.py b/test/orm/test_load_on_fks.py
index ce88df6eb..74f7f1afd 100644
--- a/test/orm/test_load_on_fks.py
+++ b/test/orm/test_load_on_fks.py
@@ -186,7 +186,7 @@ class LoadOnFKsTest(AssertsExecutionResults, fixtures.TestBase):
         # pendings don't autoflush
         assert c3.parent is None
 
-    def test_autoflush_on_pending(self):
+    def test_autoflush_load_on_pending_on_pending(self):
         Child.parent.property.load_on_pending = True
         c3 = Child()
         sess.add(c3)
diff --git a/test/orm/test_manytomany.py b/test/orm/test_manytomany.py
index 1bd730b22..226415e34 100644
--- a/test/orm/test_manytomany.py
+++ b/test/orm/test_manytomany.py
@@ -231,7 +231,16 @@ class M2MTest(fixtures.MappedTest):
         """test that a mapper can have two eager relationships to the same table, via
         two different association tables.  aliases are required."""
 
-        place_input, transition, Transition, PlaceThingy, place, place_thingy, Place, place_output = (
+        (
+            place_input,
+            transition,
+            Transition,
+            PlaceThingy,
+            place,
+            place_thingy,
+            Place,
+            place_output,
+        ) = (
             self.tables.place_input,
             self.tables.transition,
             self.classes.Transition,
diff --git a/test/orm/test_mapper.py b/test/orm/test_mapper.py
index 28076f6e5..bdf2f8a3f 100644
--- a/test/orm/test_mapper.py
+++ b/test/orm/test_mapper.py
@@ -326,8 +326,8 @@ class MapperTest(_fixtures.FixtureTest, AssertsCompiledSQL):
         """
 
         class Foo(object):
-            def __init__(self, id):
-                self.id = id
+            def __init__(self, id_):
+                self.id = id_
 
         m = MetaData()
         foo_t = Table("foo", m, Column("id", String, primary_key=True))
@@ -337,10 +337,10 @@ class MapperTest(_fixtures.FixtureTest, AssertsCompiledSQL):
             if util.py2k:
 
                 def __lt__(self, other):
-                    assert not isinstance(other, basestring)
+                    assert not isinstance(other, basestring)  # noqa
                     return int(self) < other
 
-        foos = [Foo(id="f%d" % i) for i in range(5)]
+        foos = [Foo(id_="f%d" % i) for i in range(5)]
         states = [attributes.instance_state(f) for f in foos]
 
         for s in states[0:3]:
@@ -2524,7 +2524,20 @@ class OptionsTest(_fixtures.FixtureTest):
         self.sql_count_(4, go)
 
     def test_eager_degrade_deep(self):
-        users, Keyword, items, order_items, orders, Item, User, Address, keywords, item_keywords, Order, addresses = (
+        (
+            users,
+            Keyword,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            keywords,
+            item_keywords,
+            Order,
+            addresses,
+        ) = (
             self.tables.users,
             self.classes.Keyword,
             self.tables.items,
@@ -2677,7 +2690,18 @@ class OptionsTest(_fixtures.FixtureTest):
 class DeepOptionsTest(_fixtures.FixtureTest):
     @classmethod
     def setup_mappers(cls):
-        users, Keyword, items, order_items, Order, Item, User, keywords, item_keywords, orders = (
+        (
+            users,
+            Keyword,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            keywords,
+            item_keywords,
+            orders,
+        ) = (
             cls.tables.users,
             cls.classes.Keyword,
             cls.tables.items,
@@ -3702,8 +3726,8 @@ class RequirementsTest(fixtures.MappedTest):
             #  sa.exc.ArgumentError, mapper, NoWeakrefSupport, t2)
 
     class _ValueBase(object):
-        def __init__(self, value="abc", id=None):
-            self.id = id
+        def __init__(self, value="abc", id_=None):
+            self.id = id_
             self.value = value
 
         def __bool__(self):
@@ -3830,15 +3854,15 @@ class RequirementsTest(fixtures.MappedTest):
         ht2, ht1 = (self.tables.ht2, self.tables.ht1)
 
         class H1(self._ValueBase):
-            def __init__(self, value, id, h2s):
+            def __init__(self, value, id_, h2s):
                 self.value = value
-                self.id = id
+                self.id = id_
                 self.h2s = h2s
 
         class H2(self._ValueBase):
-            def __init__(self, value, id):
+            def __init__(self, value, id_):
                 self.value = value
-                self.id = id
+                self.id = id_
 
         mapper(H1, ht1, properties={"h2s": relationship(H2, backref="h1")})
         mapper(H2, ht2)
@@ -3848,12 +3872,12 @@ class RequirementsTest(fixtures.MappedTest):
                 H1(
                     "abc",
                     1,
-                    h2s=[H2("abc", id=1), H2("def", id=2), H2("def", id=3)],
+                    h2s=[H2("abc", id_=1), H2("def", id_=2), H2("def", id_=3)],
                 ),
                 H1(
                     "def",
                     2,
-                    h2s=[H2("abc", id=4), H2("abc", id=5), H2("def", id=6)],
+                    h2s=[H2("abc", id_=4), H2("abc", id_=5), H2("def", id_=6)],
                 ),
             ]
         )
diff --git a/test/orm/test_pickled.py b/test/orm/test_pickled.py
index f9118af58..c3191c948 100644
--- a/test/orm/test_pickled.py
+++ b/test/orm/test_pickled.py
@@ -677,8 +677,8 @@ class TupleLabelTest(_fixtures.FixtureTest):
         )
         mapper(Address, addresses)
         mapper(
-            Order, orders, properties={"address": relationship(Address)}  # m2o
-        )
+            Order, orders, properties={"address": relationship(Address)}
+        )  # m2o
 
     def test_tuple_labeling(self):
         users = self.tables.users
diff --git a/test/orm/test_query.py b/test/orm/test_query.py
index 9d09cdc04..15f22df7f 100644
--- a/test/orm/test_query.py
+++ b/test/orm/test_query.py
@@ -4739,7 +4739,20 @@ class SynonymTest(QueryTest, AssertsCompiledSQL):
 
     @classmethod
     def setup_mappers(cls):
-        users, Keyword, items, order_items, orders, Item, User, Address, keywords, Order, item_keywords, addresses = (
+        (
+            users,
+            Keyword,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            keywords,
+            Order,
+            item_keywords,
+            addresses,
+        ) = (
             cls.tables.users,
             cls.classes.Keyword,
             cls.tables.items,
diff --git a/test/orm/test_relationships.py b/test/orm/test_relationships.py
index c447f44c1..3bc9667df 100644
--- a/test/orm/test_relationships.py
+++ b/test/orm/test_relationships.py
@@ -805,15 +805,15 @@ class CompositeSelfRefFKTest(fixtures.MappedTest, AssertsCompiledSQL):
 
     this is a very unusual case::
 
-    company         employee
-    ----------      ----------
-    company_id <--- company_id ------+
-    name                ^            |
-                        +------------+
-
-                    emp_id <---------+
-                    name             |
-                    reports_to_id ---+
+        company         employee
+        ----------      ----------
+        company_id <--- company_id ------+
+        name                ^            |
+                            +------------+
+
+                        emp_id <---------+
+                        name             |
+                        reports_to_id ---+
 
     employee joins to its sub-employees
     both on reports_to_id, *and on company_id to itself*.
diff --git a/test/orm/test_scoping.py b/test/orm/test_scoping.py
index ca3ff6c3f..41e5124d4 100644
--- a/test/orm/test_scoping.py
+++ b/test/orm/test_scoping.py
@@ -15,22 +15,6 @@ from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 
 
-class _ScopedTest(fixtures.MappedTest):
-    """Adds another lookup bucket to emulate Session globals."""
-
-    run_setup_mappers = "once"
-
-    @classmethod
-    def setup_class(cls):
-        cls.scoping = _base.adict()
-        super(_ScopedTest, cls).setup_class()
-
-    @classmethod
-    def teardown_class(cls):
-        cls.scoping.clear()
-        super(_ScopedTest, cls).teardown_class()
-
-
 class ScopedSessionTest(fixtures.MappedTest):
     @classmethod
     def define_tables(cls, metadata):
diff --git a/test/orm/test_selectin_relations.py b/test/orm/test_selectin_relations.py
index 12be01644..bce02173e 100644
--- a/test/orm/test_selectin_relations.py
+++ b/test/orm/test_selectin_relations.py
@@ -529,7 +529,18 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
         self._do_mapper_test(self._pathing_runs)
 
     def _do_options_test(self, configs):
-        users, Keyword, orders, items, order_items, Order, Item, User, keywords, item_keywords = (
+        (
+            users,
+            Keyword,
+            orders,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            keywords,
+            item_keywords,
+        ) = (
             self.tables.users,
             self.classes.Keyword,
             self.tables.orders,
@@ -589,7 +600,18 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
             self._do_query_tests(options, count)
 
     def _do_mapper_test(self, configs):
-        users, Keyword, orders, items, order_items, Order, Item, User, keywords, item_keywords = (
+        (
+            users,
+            Keyword,
+            orders,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            keywords,
+            item_keywords,
+        ) = (
             self.tables.users,
             self.classes.Keyword,
             self.tables.orders,
@@ -843,7 +865,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
         """Eager loading with two relationships simultaneously,
         from the same table, using aliases."""
 
-        addresses, items, order_items, orders, Item, User, Address, Order, users = (
+        (
+            addresses,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            Order,
+            users,
+        ) = (
             self.tables.addresses,
             self.tables.items,
             self.tables.order_items,
@@ -949,7 +981,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
     def test_limit(self):
         """Limit operations combined with lazy-load relationships."""
 
-        users, items, order_items, orders, Item, User, Address, Order, addresses = (
+        (
+            users,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            Order,
+            addresses,
+        ) = (
             self.tables.users,
             self.tables.items,
             self.tables.order_items,
diff --git a/test/orm/test_session.py b/test/orm/test_session.py
index 6fa90370e..fd7971011 100644
--- a/test/orm/test_session.py
+++ b/test/orm/test_session.py
@@ -1384,12 +1384,12 @@ class StrongIdentityMapTest(_fixtures.FixtureTest):
         # o is still in local scope here, so still present
         self.assert_(len(s.identity_map) == 1)
 
-        id = o.id
+        id_ = o.id
         del o
         eq_(prune(), 1)
         self.assert_(len(s.identity_map) == 0)
 
-        u = s.query(User).get(id)
+        u = s.query(User).get(id_)
         eq_(prune(), 0)
         self.assert_(len(s.identity_map) == 1)
         u.name = "squiznart"
@@ -1408,7 +1408,7 @@ class StrongIdentityMapTest(_fixtures.FixtureTest):
         eq_(prune(), 1)
         self.assert_(len(s.identity_map) == 0)
 
-        u = s.query(User).get(id)
+        u = s.query(User).get(id_)
         s.delete(u)
         del u
         eq_(prune(), 0)
diff --git a/test/orm/test_subquery_relations.py b/test/orm/test_subquery_relations.py
index 5fc7a1528..1374d55d8 100644
--- a/test/orm/test_subquery_relations.py
+++ b/test/orm/test_subquery_relations.py
@@ -529,7 +529,18 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
         self._do_mapper_test(self._pathing_runs)
 
     def _do_options_test(self, configs):
-        users, Keyword, orders, items, order_items, Order, Item, User, keywords, item_keywords = (
+        (
+            users,
+            Keyword,
+            orders,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            keywords,
+            item_keywords,
+        ) = (
             self.tables.users,
             self.classes.Keyword,
             self.tables.orders,
@@ -585,7 +596,18 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
             self._do_query_tests(options, count)
 
     def _do_mapper_test(self, configs):
-        users, Keyword, orders, items, order_items, Order, Item, User, keywords, item_keywords = (
+        (
+            users,
+            Keyword,
+            orders,
+            items,
+            order_items,
+            Order,
+            Item,
+            User,
+            keywords,
+            item_keywords,
+        ) = (
             self.tables.users,
             self.classes.Keyword,
             self.tables.orders,
@@ -862,7 +884,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
         """Eager loading with two relationships simultaneously,
         from the same table, using aliases."""
 
-        addresses, items, order_items, orders, Item, User, Address, Order, users = (
+        (
+            addresses,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            Order,
+            users,
+        ) = (
             self.tables.addresses,
             self.tables.items,
             self.tables.order_items,
@@ -968,7 +1000,17 @@ class EagerTest(_fixtures.FixtureTest, testing.AssertsCompiledSQL):
     def test_limit(self):
         """Limit operations combined with lazy-load relationships."""
 
-        users, items, order_items, orders, Item, User, Address, Order, addresses = (
+        (
+            users,
+            items,
+            order_items,
+            orders,
+            Item,
+            User,
+            Address,
+            Order,
+            addresses,
+        ) = (
             self.tables.users,
             self.tables.items,
             self.tables.order_items,
diff --git a/test/orm/test_unitofwork.py b/test/orm/test_unitofwork.py
index 6ab1ed505..86e64d202 100644
--- a/test/orm/test_unitofwork.py
+++ b/test/orm/test_unitofwork.py
@@ -2020,9 +2020,10 @@ class SaveTest(_fixtures.FixtureTest):
         session.flush()
         session.expunge_all()
 
-        id = m.primary_key_from_instance(u)
+        id_ = m.primary_key_from_instance(u)
 
-        u = session.query(User).get(id)
+        u = session.query(User).get(id_)
+>>>>>>> 380f75c05... flake8 refactor - test_orm
         assert u.name == "multitester"
 
         user_rows = (
@@ -2048,7 +2049,7 @@ class SaveTest(_fixtures.FixtureTest):
         eq_(list(address_rows[0].values()), [u.id, u.foo_id, "lala@hey.com"])
 
         session.expunge_all()
-        u = session.query(User).get(id)
+        u = session.query(User).get(id_)
         assert u.name == "imnew"
 
     def test_history_get(self):
@@ -2877,7 +2878,7 @@ class BooleanColTest(fixtures.MappedTest):
         class T(fixtures.ComparableEntity):
             pass
 
-        orm_mapper(T, t1_t)
+        mapper(T, t1_t)
 
         sess = create_session()
         t1 = T(value=True, name="t1")
@@ -3226,8 +3227,8 @@ class TransactionTest(fixtures.MappedTest):
             cls.tables.t1,
         )
 
-        orm_mapper(T1, t1)
-        orm_mapper(T2, t2)
+        mapper(T1, t1)
+        mapper(T2, t2)
 
     def test_close_transaction_on_commit_fail(self):
         T2, t1 = self.classes.T2, self.tables.t1
@@ -3274,7 +3275,7 @@ class PartialNullPKTest(fixtures.MappedTest):
 
     @classmethod
     def setup_mappers(cls):
-        orm_mapper(cls.classes.T1, cls.tables.t1)
+        mapper(cls.classes.T1, cls.tables.t1)
 
     def test_key_switch(self):
         T1 = self.classes.T1
@@ -3339,3 +3340,4 @@ class PartialNullPKTest(fixtures.MappedTest):
 
         t.col1 = "1"
         s.commit()
+