- rework profiling, zoomark tests into single tests so that

they can be used under xdist

3 files changed, 151 insertions, 239 deletions

diff --git a/test/aaa_profiling/test_compiler.py b/test/aaa_profiling/test_compiler.py
index 47a412e73..5eece4602 100644
--- a/test/aaa_profiling/test_compiler.py
+++ b/test/aaa_profiling/test_compiler.py
@@ -42,7 +42,7 @@ class CompileTest(fixtures.TestBase, AssertsExecutionResults):
     def test_insert(self):
         t1.insert().compile(dialect=self.dialect)
 
-    @profiling.function_call_count()
+    @profiling.function_call_count(variance=.15)
     def test_update(self):
         t1.update().compile(dialect=self.dialect)
 
diff --git a/test/aaa_profiling/test_zoomark.py b/test/aaa_profiling/test_zoomark.py
index 4c4708503..5b8a0f785 100644
--- a/test/aaa_profiling/test_zoomark.py
+++ b/test/aaa_profiling/test_zoomark.py
@@ -7,43 +7,42 @@ An adaptation of Robert Brewers' ZooMark speed tests. """
 
 import datetime
 from sqlalchemy import Table, Column, Integer, Unicode, Date, \
-    DateTime, Time, Float, MetaData, Sequence, ForeignKey, create_engine, \
+    DateTime, Time, Float, Sequence, ForeignKey,  \
     select, join, and_, outerjoin, func
-from sqlalchemy.testing import fixtures, engines, profiling
-from sqlalchemy import testing
-ITERATIONS = 1
-dbapi_session = engines.ReplayableSession()
-metadata = None
-
+from sqlalchemy.testing import replay_fixture
 
-class ZooMarkTest(fixtures.TestBase):
+ITERATIONS = 1
 
-    """Runs the ZooMark and squawks if method counts vary from the norm.
 
-    Each test has an associated `call_range`, the total number of
-    accepted function calls made during the test.  The count can vary
-    between Python 2.4 and 2.5.
+class ZooMarkTest(replay_fixture.ReplayFixtureTest):
 
-    Unlike a unit test, this is a ordered collection of steps.  Running
-    components individually will fail.
+    """Runs the ZooMark and squawks if method counts vary from the norm."""
 
-    """
     __requires__ = 'cpython',
     __only_on__ = 'postgresql+psycopg2'
 
-    def test_baseline_0_setup(self):
-        global metadata
-        creator = testing.db.pool._creator
-        recorder = lambda: dbapi_session.recorder(creator())
-        engine = engines.testing_engine(options={'creator': recorder,
-                                                 'use_reaper': False})
-        metadata = MetaData(engine)
-        engine.connect()
-
-    def test_baseline_1_create_tables(self):
+    def _run_steps(self, ctx):
+        self._baseline_1_create_tables()
+        with ctx():
+            self._baseline_1a_populate()
+        with ctx():
+            self._baseline_2_insert()
+        with ctx():
+            self._baseline_3_properties()
+        with ctx():
+            self._baseline_4_expressions()
+        with ctx():
+            self._baseline_5_aggregates()
+        with ctx():
+            self._baseline_6_editing()
+        with ctx():
+            self._baseline_7_multiview()
+        self._baseline_8_drop()
+
+    def _baseline_1_create_tables(self):
         Table(
             'Zoo',
-            metadata,
+            self.metadata,
             Column('ID', Integer, Sequence('zoo_id_seq'),
                    primary_key=True, index=True),
             Column('Name', Unicode(255)),
@@ -54,7 +53,7 @@ class ZooMarkTest(fixtures.TestBase):
         )
         Table(
             'Animal',
-            metadata,
+            self.metadata,
             Column('ID', Integer, Sequence('animal_id_seq'),
                    primary_key=True),
             Column('ZooID', Integer, ForeignKey('Zoo.ID'), index=True),
@@ -67,12 +66,12 @@ class ZooMarkTest(fixtures.TestBase):
             Column('PreferredFoodID', Integer),
             Column('AlternateFoodID', Integer),
         )
-        metadata.create_all()
+        self.metadata.create_all()
 
-    def test_baseline_1a_populate(self):
-        Zoo = metadata.tables['Zoo']
-        Animal = metadata.tables['Animal']
-        engine = metadata.bind
+    def _baseline_1a_populate(self):
+        Zoo = self.metadata.tables['Zoo']
+        Animal = self.metadata.tables['Animal']
+        engine = self.metadata.bind
         wap = engine.execute(Zoo.insert(), Name='Wild Animal Park',
                              Founded=datetime.date(2000, 1, 1),
                              Opens=datetime.time(8, 15, 59),
@@ -137,16 +136,16 @@ class ZooMarkTest(fixtures.TestBase):
         engine.execute(Animal.insert(inline=True), Species='Ape',
                        Name='Hua Mei', Legs=2, MotherID=bai_yun)
 
-    def test_baseline_2_insert(self):
-        Animal = metadata.tables['Animal']
+    def _baseline_2_insert(self):
+        Animal = self.metadata.tables['Animal']
         i = Animal.insert(inline=True)
         for x in range(ITERATIONS):
             i.execute(Species='Tick', Name='Tick %d' % x, Legs=8)
 
-    def test_baseline_3_properties(self):
-        Zoo = metadata.tables['Zoo']
-        Animal = metadata.tables['Animal']
-        engine = metadata.bind
+    def _baseline_3_properties(self):
+        Zoo = self.metadata.tables['Zoo']
+        Animal = self.metadata.tables['Animal']
+        engine = self.metadata.bind
 
         def fullobject(select):
             """Iterate over the full result row."""
@@ -171,10 +170,10 @@ class ZooMarkTest(fixtures.TestBase):
             fullobject(Animal.select(Animal.c.Legs == 1000000))
             fullobject(Animal.select(Animal.c.Species == 'Tick'))
 
-    def test_baseline_4_expressions(self):
-        Zoo = metadata.tables['Zoo']
-        Animal = metadata.tables['Animal']
-        engine = metadata.bind
+    def _baseline_4_expressions(self):
+        Zoo = self.metadata.tables['Zoo']
+        Animal = self.metadata.tables['Animal']
+        engine = self.metadata.bind
 
         def fulltable(select):
             """Iterate over the full result table."""
@@ -280,10 +279,10 @@ class ZooMarkTest(fixtures.TestBase):
                             'day',
                             Animal.c.LastEscape) == 21))) == 1
 
-    def test_baseline_5_aggregates(self):
-        Animal = metadata.tables['Animal']
-        Zoo = metadata.tables['Zoo']
-        engine = metadata.bind
+    def _baseline_5_aggregates(self):
+        Animal = self.metadata.tables['Animal']
+        Zoo = self.metadata.tables['Zoo']
+        engine = self.metadata.bind
 
         for x in range(ITERATIONS):
 
@@ -327,9 +326,9 @@ class ZooMarkTest(fixtures.TestBase):
                            distinct=True)).fetchall()]
             legs.sort()
 
-    def test_baseline_6_editing(self):
-        Zoo = metadata.tables['Zoo']
-        engine = metadata.bind
+    def _baseline_6_editing(self):
+        Zoo = self.metadata.tables['Zoo']
+        engine = self.metadata.bind
         for x in range(ITERATIONS):
 
             # Edit
@@ -364,10 +363,10 @@ class ZooMarkTest(fixtures.TestBase):
                                             )).first()
             assert SDZ['Founded'] == datetime.date(1935, 9, 13)
 
-    def test_baseline_7_multiview(self):
-        Zoo = metadata.tables['Zoo']
-        Animal = metadata.tables['Animal']
-        engine = metadata.bind
+    def _baseline_7_multiview(self):
+        Zoo = self.metadata.tables['Zoo']
+        Animal = self.metadata.tables['Animal']
+        engine = self.metadata.bind
 
         def fulltable(select):
             """Iterate over the full result table."""
@@ -403,52 +402,6 @@ class ZooMarkTest(fixtures.TestBase):
                 Zoo.c.Name, Animal.c.Species],
                 from_obj=[outerjoin(Animal, Zoo)]))
 
-    def test_baseline_8_drop(self):
-        metadata.drop_all()
-
-    # Now, run all of these tests again with the DB-API driver factored
-    # out: the ReplayableSession playback stands in for the database.
-    #
-    # How awkward is this in a unittest framework?  Very.
-
-    def test_profile_0(self):
-        global metadata
-        player = lambda: dbapi_session.player()
-        engine = create_engine('postgresql:///', creator=player,
-                               use_native_hstore=False)
-        metadata = MetaData(engine)
-        engine.connect()
-
-    def test_profile_1_create_tables(self):
-        self.test_baseline_1_create_tables()
-
-    @profiling.function_call_count()
-    def test_profile_1a_populate(self):
-        self.test_baseline_1a_populate()
-
-    @profiling.function_call_count()
-    def test_profile_2_insert(self):
-        self.test_baseline_2_insert()
-
-    @profiling.function_call_count()
-    def test_profile_3_properties(self):
-        self.test_baseline_3_properties()
-
-    @profiling.function_call_count()
-    def test_profile_4_expressions(self):
-        self.test_baseline_4_expressions()
-
-    @profiling.function_call_count()
-    def test_profile_5_aggregates(self):
-        self.test_baseline_5_aggregates()
-
-    @profiling.function_call_count()
-    def test_profile_6_editing(self):
-        self.test_baseline_6_editing()
-
-    @profiling.function_call_count()
-    def test_profile_7_multiview(self):
-        self.test_baseline_7_multiview()
+    def _baseline_8_drop(self):
+        self.metadata.drop_all()
 
-    def test_profile_8_drop(self):
-        self.test_baseline_8_drop()
diff --git a/test/aaa_profiling/test_zoomark_orm.py b/test/aaa_profiling/test_zoomark_orm.py
index 6b781af9b..500d7c2cb 100644
--- a/test/aaa_profiling/test_zoomark_orm.py
+++ b/test/aaa_profiling/test_zoomark_orm.py
@@ -7,48 +7,52 @@ An adaptation of Robert Brewers' ZooMark speed tests. """
 
 import datetime
 from sqlalchemy import Table, Column, Integer, Unicode, Date, \
-    DateTime, Time, Float, MetaData, Sequence, ForeignKey, create_engine, \
+    DateTime, Time, Float, Sequence, ForeignKey, \
     select, and_, func
-from sqlalchemy.orm import sessionmaker, mapper
-from sqlalchemy.testing import fixtures, engines, profiling
-from sqlalchemy import testing
+from sqlalchemy.orm import mapper
+from sqlalchemy.testing import replay_fixture
+
 ITERATIONS = 1
-dbapi_session = engines.ReplayableSession()
-metadata = None
 
 Zoo = Animal = session = None
 
 
-class ZooMarkTest(fixtures.TestBase):
+class ZooMarkTest(replay_fixture.ReplayFixtureTest):
 
     """Runs the ZooMark and squawks if method counts vary from the norm.
 
-    Each test has an associated `call_range`, the total number of
-    accepted function calls made during the test.  The count can vary
-    between Python 2.4 and 2.5.
-
-    Unlike a unit test, this is a ordered collection of steps.  Running
-    components individually will fail.
 
     """
 
     __requires__ = 'cpython',
     __only_on__ = 'postgresql+psycopg2'
 
-    def test_baseline_0_setup(self):
-        global metadata, session
-        creator = testing.db.pool._creator
-        recorder = lambda: dbapi_session.recorder(creator())
-        engine = engines.testing_engine(
-            options={'creator': recorder, 'use_reaper': False})
-        metadata = MetaData(engine)
-        session = sessionmaker(engine)()
-        engine.connect()
-
-    def test_baseline_1_create_tables(self):
+    def _run_steps(self, ctx):
+        #self._baseline_1_create_tables()
+        with ctx():
+            self._baseline_1a_populate()
+        with ctx():
+            self._baseline_2_insert()
+        with ctx():
+            self._baseline_3_properties()
+        with ctx():
+            self._baseline_4_expressions()
+        with ctx():
+            self._baseline_5_aggregates()
+        with ctx():
+            self._baseline_6_editing()
+        #self._baseline_7_drop()
+
+    def setup_engine(self):
+        self._baseline_1_create_tables()
+
+    def teardown_engine(self):
+        self._baseline_7_drop()
+
+    def _baseline_1_create_tables(self):
         zoo = Table(
             'Zoo',
-            metadata,
+            self.metadata,
             Column('ID', Integer, Sequence('zoo_id_seq'),
                    primary_key=True, index=True),
             Column('Name', Unicode(255)),
@@ -59,7 +63,7 @@ class ZooMarkTest(fixtures.TestBase):
         )
         animal = Table(
             'Animal',
-            metadata,
+            self.metadata,
             Column('ID', Integer, Sequence('animal_id_seq'),
                    primary_key=True),
             Column('ZooID', Integer, ForeignKey('Zoo.ID'), index=True),
@@ -72,7 +76,7 @@ class ZooMarkTest(fixtures.TestBase):
             Column('PreferredFoodID', Integer),
             Column('AlternateFoodID', Integer),
         )
-        metadata.create_all()
+        self.metadata.create_all()
         global Zoo, Animal
 
         class Zoo(object):
@@ -90,131 +94,129 @@ class ZooMarkTest(fixtures.TestBase):
         mapper(Zoo, zoo)
         mapper(Animal, animal)
 
-    def test_baseline_1a_populate(self):
+    def _baseline_1a_populate(self):
         wap = Zoo(
             Name='Wild Animal Park', Founded=datetime.date(
                 2000, 1, 1), Opens=datetime.time(
                 8, 15, 59), LastEscape=datetime.datetime(
                 2004, 7, 29, 5, 6, 7, ), Admission=4.95)
-        session.add(wap)
+        self.session.add(wap)
         sdz = Zoo(
             Name='San Diego Zoo', Founded=datetime.date(
                 1835, 9, 13), Opens=datetime.time(
                 9, 0, 0), Admission=0)
-        session.add(sdz)
+        self.session.add(sdz)
         bio = Zoo(Name='Montr\xe9al Biod\xf4me',
                   Founded=datetime.date(1992, 6, 19),
                   Opens=datetime.time(9, 0, 0), Admission=11.75)
-        session.add(bio)
+        self.session.add(bio)
         seaworld = Zoo(Name='Sea_World', Admission=60)
-        session.add(seaworld)
+        self.session.add(seaworld)
 
         # Let's add a crazy futuristic Zoo to test large date values.
 
         lp = Zoo(Name='Luna Park', Founded=datetime.date(2072, 7, 17),
                  Opens=datetime.time(0, 0, 0), Admission=134.95)
-        session.add(lp)
-        session.flush()
+        self.session.add(lp)
 
         # Animals
 
         leopard = Animal(Species='Leopard', Lifespan=73.5)
-        session.add(leopard)
+        self.session.add(leopard)
         leopard.ZooID = wap.ID
         leopard.LastEscape = \
             datetime.datetime(2004, 12, 21, 8, 15, 0, 999907, )
-        session.add(Animal(Species='Lion', ZooID=wap.ID))
-        session.add(Animal(Species='Slug', Legs=1, Lifespan=.75))
-        session.add(Animal(Species='Tiger', ZooID=sdz.ID))
+        self.session.add(Animal(Species='Lion', ZooID=wap.ID))
+        self.session.add(Animal(Species='Slug', Legs=1, Lifespan=.75))
+        self.session.add(Animal(Species='Tiger', ZooID=sdz.ID))
 
         # Override Legs.default with itself just to make sure it works.
 
-        session.add(Animal(Species='Bear', Legs=4))
-        session.add(Animal(Species='Ostrich', Legs=2, Lifespan=103.2))
-        session.add(Animal(Species='Centipede', Legs=100))
-        session.add(Animal(Species='Emperor Penguin', Legs=2,
+        self.session.add(Animal(Species='Bear', Legs=4))
+        self.session.add(Animal(Species='Ostrich', Legs=2, Lifespan=103.2))
+        self.session.add(Animal(Species='Centipede', Legs=100))
+        self.session.add(Animal(Species='Emperor Penguin', Legs=2,
                            ZooID=seaworld.ID))
-        session.add(Animal(Species='Adelie Penguin', Legs=2,
+        self.session.add(Animal(Species='Adelie Penguin', Legs=2,
                            ZooID=seaworld.ID))
-        session.add(Animal(Species='Millipede', Legs=1000000,
+        self.session.add(Animal(Species='Millipede', Legs=1000000,
                            ZooID=sdz.ID))
 
         # Add a mother and child to test relationships
 
         bai_yun = Animal(Species='Ape', Nameu='Bai Yun', Legs=2)
-        session.add(bai_yun)
-        session.add(Animal(Species='Ape', Name='Hua Mei', Legs=2,
+        self.session.add(bai_yun)
+        self.session.add(Animal(Species='Ape', Name='Hua Mei', Legs=2,
                            MotherID=bai_yun.ID))
-        session.flush()
-        session.commit()
+        self.session.commit()
 
-    def test_baseline_2_insert(self):
+    def _baseline_2_insert(self):
         for x in range(ITERATIONS):
-            session.add(Animal(Species='Tick', Name='Tick %d' % x,
+            self.session.add(Animal(Species='Tick', Name='Tick %d' % x,
                                Legs=8))
-        session.flush()
+        self.session.flush()
 
-    def test_baseline_3_properties(self):
+    def _baseline_3_properties(self):
         for x in range(ITERATIONS):
 
             # Zoos
 
-            list(session.query(Zoo).filter(
+            list(self.session.query(Zoo).filter(
                 Zoo.Name == 'Wild Animal Park'))
             list(
-                session.query(Zoo).filter(
+                self.session.query(Zoo).filter(
                     Zoo.Founded == datetime.date(
                         1835,
                         9,
                         13)))
             list(
-                session.query(Zoo).filter(
+                self.session.query(Zoo).filter(
                     Zoo.Name == 'Montr\xe9al Biod\xf4me'))
-            list(session.query(Zoo).filter(Zoo.Admission == float(60)))
+            list(self.session.query(Zoo).filter(Zoo.Admission == float(60)))
 
             # Animals
 
-            list(session.query(Animal).filter(Animal.Species == 'Leopard'))
-            list(session.query(Animal).filter(Animal.Species == 'Ostrich'))
-            list(session.query(Animal).filter(Animal.Legs == 1000000))
-            list(session.query(Animal).filter(Animal.Species == 'Tick'))
+            list(self.session.query(Animal).filter(Animal.Species == 'Leopard'))
+            list(self.session.query(Animal).filter(Animal.Species == 'Ostrich'))
+            list(self.session.query(Animal).filter(Animal.Legs == 1000000))
+            list(self.session.query(Animal).filter(Animal.Species == 'Tick'))
 
-    def test_baseline_4_expressions(self):
+    def _baseline_4_expressions(self):
         for x in range(ITERATIONS):
-            assert len(list(session.query(Zoo))) == 5
-            assert len(list(session.query(Animal))) == ITERATIONS + 12
-            assert len(list(session.query(Animal).filter(Animal.Legs
+            assert len(list(self.session.query(Zoo))) == 5
+            assert len(list(self.session.query(Animal))) == ITERATIONS + 12
+            assert len(list(self.session.query(Animal).filter(Animal.Legs
                                                          == 4))) == 4
-            assert len(list(session.query(Animal).filter(Animal.Legs
+            assert len(list(self.session.query(Animal).filter(Animal.Legs
                                                          == 2))) == 5
             assert len(
                 list(
-                    session.query(Animal).filter(
+                    self.session.query(Animal).filter(
                         and_(
                             Animal.Legs >= 2,
                             Animal.Legs < 20)))) == ITERATIONS + 9
-            assert len(list(session.query(Animal).filter(Animal.Legs
+            assert len(list(self.session.query(Animal).filter(Animal.Legs
                                                          > 10))) == 2
-            assert len(list(session.query(Animal).filter(Animal.Lifespan
+            assert len(list(self.session.query(Animal).filter(Animal.Lifespan
                                                          > 70))) == 2
-            assert len(list(session.query(Animal).
+            assert len(list(self.session.query(Animal).
                             filter(Animal.Species.like('L%')))) == 2
-            assert len(list(session.query(Animal).
+            assert len(list(self.session.query(Animal).
                             filter(Animal.Species.like('%pede')))) == 2
-            assert len(list(session.query(Animal).filter(Animal.LastEscape
+            assert len(list(self.session.query(Animal).filter(Animal.LastEscape
                                                          != None))) == 1
             assert len(
                 list(
-                    session.query(Animal).filter(
+                    self.session.query(Animal).filter(
                         Animal.LastEscape == None))) == ITERATIONS + 11
 
             # In operator (containedby)
 
-            assert len(list(session.query(Animal).filter(
+            assert len(list(self.session.query(Animal).filter(
                 Animal.Species.like('%pede%')))) == 2
             assert len(
                 list(
-                    session.query(Animal). filter(
+                    self.session.query(Animal). filter(
                         Animal.Species.in_(
                             ('Lion', 'Tiger', 'Bear'))))) == 3
 
@@ -224,17 +226,17 @@ class ZooMarkTest(fixtures.TestBase):
 
             pet, pet2 = thing(), thing()
             pet.Name, pet2.Name = 'Slug', 'Ostrich'
-            assert len(list(session.query(Animal).
+            assert len(list(self.session.query(Animal).
                             filter(Animal.Species.in_((pet.Name,
                                                        pet2.Name))))) == 2
 
             # logic and other functions
 
             name = 'Lion'
-            assert len(list(session.query(Animal).
+            assert len(list(self.session.query(Animal).
                             filter(func.length(Animal.Species)
                                    == len(name)))) == ITERATIONS + 3
-            assert len(list(session.query(Animal).
+            assert len(list(self.session.query(Animal).
                             filter(Animal.Species.like('%i%'
                                                        )))) == ITERATIONS + 7
 
@@ -242,29 +244,29 @@ class ZooMarkTest(fixtures.TestBase):
 
             assert len(
                 list(
-                    session.query(Zoo).filter(
+                    self.session.query(Zoo).filter(
                         and_(
                             Zoo.Founded != None,
                             Zoo.Founded < func.now())))) == 3
-            assert len(list(session.query(Animal).filter(Animal.LastEscape
+            assert len(list(self.session.query(Animal).filter(Animal.LastEscape
                                                          == func.now()))) == 0
-            assert len(list(session.query(Animal).filter(
+            assert len(list(self.session.query(Animal).filter(
                 func.date_part('year', Animal.LastEscape) == 2004))) == 1
             assert len(
                 list(
-                    session.query(Animal). filter(
+                    self.session.query(Animal). filter(
                         func.date_part(
                             'month',
                             Animal.LastEscape) == 12))) == 1
-            assert len(list(session.query(Animal).filter(
+            assert len(list(self.session.query(Animal).filter(
                 func.date_part('day', Animal.LastEscape) == 21))) == 1
 
-    def test_baseline_5_aggregates(self):
-        Animal = metadata.tables['Animal']
-        Zoo = metadata.tables['Zoo']
+    def _baseline_5_aggregates(self):
+        Animal = self.metadata.tables['Animal']
+        Zoo = self.metadata.tables['Zoo']
 
         # TODO: convert to ORM
-        engine = metadata.bind
+        engine = self.metadata.bind
         for x in range(ITERATIONS):
 
             # views
@@ -307,12 +309,12 @@ class ZooMarkTest(fixtures.TestBase):
                            distinct=True)).fetchall()]
             legs.sort()
 
-    def test_baseline_6_editing(self):
+    def _baseline_6_editing(self):
         for x in range(ITERATIONS):
 
             # Edit
 
-            SDZ = session.query(Zoo).filter(Zoo.Name == 'San Diego Zoo'
+            SDZ = self.session.query(Zoo).filter(Zoo.Name == 'San Diego Zoo'
                                             ).one()
             SDZ.Name = 'The San Diego Zoo'
             SDZ.Founded = datetime.date(1900, 1, 1)
@@ -321,7 +323,7 @@ class ZooMarkTest(fixtures.TestBase):
 
             # Test edits
 
-            SDZ = session.query(Zoo).filter(Zoo.Name
+            SDZ = self.session.query(Zoo).filter(Zoo.Name
                                             == 'The San Diego Zoo').one()
             assert SDZ.Founded == datetime.date(1900, 1, 1), SDZ.Founded
 
@@ -334,55 +336,12 @@ class ZooMarkTest(fixtures.TestBase):
 
             # Test re-edits
 
-            SDZ = session.query(Zoo).filter(Zoo.Name == 'San Diego Zoo'
+            SDZ = self.session.query(Zoo).filter(Zoo.Name == 'San Diego Zoo'
                                             ).one()
             assert SDZ.Founded == datetime.date(1835, 9, 13), \
                 SDZ.Founded
 
-    def test_baseline_7_drop(self):
-        session.rollback()
-        metadata.drop_all()
-
-    # Now, run all of these tests again with the DB-API driver factored
-    # out: the ReplayableSession playback stands in for the database.
-    #
-    # How awkward is this in a unittest framework?  Very.
-
-    def test_profile_0(self):
-        global metadata, session
-        player = lambda: dbapi_session.player()
-        engine = create_engine('postgresql:///', creator=player,
-                               use_native_hstore=False)
-        metadata = MetaData(engine)
-        session = sessionmaker(engine)()
-        engine.connect()
-
-    def test_profile_1_create_tables(self):
-        self.test_baseline_1_create_tables()
-
-    @profiling.function_call_count()
-    def test_profile_1a_populate(self):
-        self.test_baseline_1a_populate()
-
-    @profiling.function_call_count()
-    def test_profile_2_insert(self):
-        self.test_baseline_2_insert()
-
-    @profiling.function_call_count()
-    def test_profile_3_properties(self):
-        self.test_baseline_3_properties()
-
-    @profiling.function_call_count()
-    def test_profile_4_expressions(self):
-        self.test_baseline_4_expressions()
-
-    @profiling.function_call_count()
-    def test_profile_5_aggregates(self):
-        self.test_baseline_5_aggregates()
-
-    @profiling.function_call_count()
-    def test_profile_6_editing(self):
-        self.test_baseline_6_editing()
-
-    def test_profile_7_drop(self):
-        self.test_baseline_7_drop()
+    def _baseline_7_drop(self):
+        self.session.rollback()
+        self.metadata.drop_all()
+