Merge lp:~lifeless/launchpad/databasefixture into lp:launchpad

[Robert Collins]

Make database test support capable of running with unique db test names.

This makes the database test support layer ready for parallel testing - we can run with unique database names. Not supported yet is having the config system unique for a test process (I'd make it more granular than that, but zcml is so global that I don't think thats feasible until we reengineer that entire stack.

Some things were no longer used, so I deleted them. Most things were trivial.

We won't see any test DB leaks at this point, but I'm worried about the possibility when we turn this on... still thats a problem for another day.

[Jonathan Lange (jml)]

On Sun, Oct 17, 2010 at 7:59 AM, Robert Collins
<email address hidden> wrote:
> Robert Collins has proposed merging lp:~lifeless/launchpad/databasefixture into lp:launchpad/devel.
>
> Requested reviews:
>  Jonathan Lange (jml)
>
>
> This makes the database test support layer ready for parallel testing - we can run with unique database names. Not supported yet is having the config system unique for a test process (I'd make it more granular than that, but zcml is so global that I don't think thats feasible until we reengineer that entire stack.
>
> Some things were no longer used, so I deleted them. Most things were trivial.
>
> We won't see any test DB leaks at this point, but I'm worried about the possibility when we turn this on... still thats a problem for another day.

As you said on IRC, it's a mostly mechanical branch. The changes all
look good to me, and definitely in the right direction.

Land when ready.

jml

[Jonathan Lange (jml)]

review: Approve

=== modified file 'lib/canonical/config/tests/test_database_config.py'
--- lib/canonical/config/tests/test_database_config.py	2010-01-13 20:06:09 +0000
+++ lib/canonical/config/tests/test_database_config.py	2010-10-17 19:12:52 +0000
@@ -3,17 +3,20 @@
 
 __metaclass__ = type
 
-from lp.testing import TestCase
-
 from canonical.config import config, dbconfig
-
 from canonical.launchpad.readonly import read_only_file_exists
 from canonical.launchpad.tests.readonly import (
-    remove_read_only_file, touch_read_only_file)
+    remove_read_only_file,
+    touch_read_only_file,
+    )
+from canonical.testing.layers import DatabaseLayer
+from lp.testing import TestCase
 
 
 class TestDatabaseConfig(TestCase):
 
+    layer = DatabaseLayer
+
     def test_overlay(self):
         # The dbconfig option overlays the database configurations of a
         # chosen config section over the base section.
@@ -25,11 +28,12 @@
         self.assertEquals('librarian', config.librarian.dbuser)
 
         dbconfig.setConfigSection('librarian')
-        self.assertEquals('dbname=launchpad_ftest', dbconfig.rw_main_master)
+        expected_db = 'dbname=%s' % DatabaseLayer._db_fixture.dbname
+        self.assertEquals(expected_db, dbconfig.rw_main_master)
         self.assertEquals('librarian', dbconfig.dbuser)
 
         dbconfig.setConfigSection('launchpad')
-        self.assertEquals('dbname=launchpad_ftest', dbconfig.rw_main_master)
+        self.assertEquals(expected_db, dbconfig.rw_main_master)
         self.assertEquals('launchpad_main', dbconfig.dbuser)
 
     def test_required_values(self):

=== modified file 'lib/canonical/database/ftests/test_postgresql.py'
--- lib/canonical/database/ftests/test_postgresql.py	2010-07-14 14:11:15 +0000
+++ lib/canonical/database/ftests/test_postgresql.py	2010-10-17 19:12:52 +0000
@@ -10,8 +10,9 @@
 def setUp(test):
 
     # Build a fresh, empty database and connect
-    PgTestSetup().setUp()
-    con = PgTestSetup().connect()
+    test._db_fixture = PgTestSetup()
+    test._db_fixture.setUp()
+    con = test._db_fixture.connect()
 
     # Create a test schema demonstrating the edge cases
     cur = con.cursor()
@@ -53,8 +54,9 @@
     test.globs['cur'] = cur
 
 def tearDown(test):
-    PgTestSetup().tearDown()
     test.globs['con'].close()
+    test._db_fixture.tearDown()
+    del test._db_fixture
 
 def test_suite():
     suite = DocTestSuite(

=== modified file 'lib/canonical/database/ftests/test_sqlbaseconnect.txt'
--- lib/canonical/database/ftests/test_sqlbaseconnect.txt	2009-04-17 10:32:16 +0000
+++ lib/canonical/database/ftests/test_sqlbaseconnect.txt	2010-10-17 19:12:52 +0000
@@ -19,7 +19,7 @@
 Specifying the user connects as that user.
 
     >>> do_connect(user=config.launchpad_session.dbuser)
-    Connected as session to launchpad_ftest in read committed isolation.
+    Connected as session to ... in read committed isolation.
 
 Specifying the database name connects to that database.
 
@@ -31,5 +31,5 @@
     >>> do_connect(
     ...     user=config.launchpad.dbuser,
     ...     isolation=ISOLATION_LEVEL_SERIALIZABLE)
-    Connected as launchpad_main to launchpad_ftest in serializable isolation.
+    Connected as launchpad_main to ... in serializable isolation.
 

=== modified file 'lib/canonical/ftests/pgsql.py'
--- lib/canonical/ftests/pgsql.py	2009-10-09 04:05:34 +0000
+++ lib/canonical/ftests/pgsql.py	2010-10-17 19:12:52 +0000
@@ -7,7 +7,7 @@
 
 __metaclass__ = type
 
-import unittest
+import os
 import time
 
 import psycopg2
@@ -119,7 +119,6 @@
 
 _org_connect = None
 def fake_connect(*args, **kw):
-    global _org_connect
     return ConnectionWrapper(_org_connect(*args, **kw))
 
 def installFakeConnect():
@@ -136,9 +135,13 @@
 
 
 class PgTestSetup:
+
     connections = [] # Shared
+    # Use a dynamically generated dbname:
+    dynamic = object()
 
     template = 'template1'
+    # Needs to match configs/testrunner*/*:
     dbname = 'launchpad_ftest'
     dbuser = None
     host = None
@@ -165,8 +168,13 @@
         '''
         if template is not None:
             self.template = template
-        if dbname is not None:
+        if dbname is PgTestSetup.dynamic:
+            self.dbname = self.__class__.dbname + "_" + str(os.getpid())
+        elif dbname is not None:
             self.dbname = dbname
+        else:
+            # Fallback to the class name.
+            self.dbname = self.__class__.dbname
         if dbuser is not None:
             self.dbuser = dbuser
         if host is not None:
@@ -331,30 +339,3 @@
         as database changes made from a subprocess.
         """
         PgTestSetup._reset_db = True
-
-
-class PgTestCase(unittest.TestCase):
-    dbname = None
-    dbuser = None
-    host = None
-    port = None
-    template = None
-    def setUp(self):
-        pg_test_setup = PgTestSetup(
-                self.template, self.dbname, self.dbuser, self.host, self.port
-                )
-        pg_test_setup.setUp()
-        self.dbname = pg_test_setup.dbname
-        self.dbuser = pg_test_setup.dbuser
-        assert self.dbname, 'self.dbname is not set.'
-
-    def tearDown(self):
-        PgTestSetup(
-                self.template, self.dbname, self.dbuser, self.host, self.port
-                ).tearDown()
-
-    def connect(self):
-        return PgTestSetup(
-                self.template, self.dbname, self.dbuser, self.host, self.port
-                ).connect()
-

=== modified file 'lib/canonical/ftests/test_pgsql.py'
--- lib/canonical/ftests/test_pgsql.py	2009-06-25 05:30:52 +0000
+++ lib/canonical/ftests/test_pgsql.py	2010-10-17 19:12:52 +0000
@@ -1,77 +1,84 @@
-# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-import unittest
-from canonical.ftests.pgsql import PgTestCase, PgTestSetup, ConnectionWrapper
-
-
-class TestPgTestCase(PgTestCase):
-
-    def testRollback(self):
-        # This test creates a table. We run the same test twice,
-        # which will fail if database changes are not rolled back
-        con = self.connect()
-        cur = con.cursor()
-        cur.execute('CREATE TABLE foo (x int)')
-        cur.execute('INSERT INTO foo VALUES (1)')
-        cur.execute('SELECT x FROM foo')
-        res = list(cur.fetchall())
-        self.failUnless(len(res) == 1)
-        self.failUnless(res[0][0] == 1)
-        con.commit()
-
-    testRollback2 = testRollback
-
-class TestOptimization(unittest.TestCase):
+import os
+
+import testtools
+
+from canonical.ftests.pgsql import (
+    ConnectionWrapper,
+    PgTestSetup,
+    )
+
+
+class TestPgTestSetup(testtools.TestCase):
+
+    def test_db_naming(self):
+        fixture = PgTestSetup(dbname=PgTestSetup.dynamic)
+        expected_name = "%s_%s" % (PgTestSetup.dbname, os.getpid())
+        self.assertEqual(expected_name, fixture.dbname)
+        fixture.setUp()
+        self.addCleanup(fixture.dropDb)
+        self.addCleanup(fixture.tearDown)
+        cur = fixture.connect().cursor()
+        cur.execute('SELECT current_database()')
+        where = cur.fetchone()[0]
+        self.assertEqual(expected_name, where)
+
     def testOptimization(self):
         # Test to ensure that the database is destroyed only when necessary
 
         # Make a change to a database
-        PgTestSetup().setUp()
+        fixture = PgTestSetup()
+        fixture.setUp()
         try:
-            con = PgTestSetup().connect()
+            con = fixture.connect()
             cur = con.cursor()
             cur.execute('CREATE TABLE foo (x int)')
             con.commit()
             # Fake it so the harness doesn't know a change has been made
             ConnectionWrapper.committed = False
         finally:
-            PgTestSetup().tearDown()
+            fixture.tearDown()
 
-        # Now check to ensure that the table we just created is still there
-        PgTestSetup().setUp()
+        # Now check to ensure that the table we just created is still there if
+        # we reuse the fixture.
+        fixture.setUp()
         try:
-            con = PgTestSetup().connect()
+            con = fixture.connect()
             cur = con.cursor()
             # This tests that the table still exists, as well as modifying the
             # db
             cur.execute('INSERT INTO foo VALUES (1)')
             con.commit()
         finally:
-            PgTestSetup().tearDown()
+            fixture.tearDown()
 
-        # Now ensure that the table is gone
-        PgTestSetup().setUp()
+        # Now ensure that the table is gone - the commit must have been rolled
+        # back.
+        fixture.setUp()
         try:
-            con = PgTestSetup().connect()
+            con = fixture.connect()
             cur = con.cursor()
             cur.execute('CREATE TABLE foo (x int)')
             con.commit()
             ConnectionWrapper.committed = False # Leave the table
         finally:
-            PgTestSetup().tearDown()
+            fixture.tearDown()
 
-        # The database should *always* be recreated if the template
-        # changes.
-        PgTestSetup._last_db = ('whatever', 'launchpad_ftest')
-        PgTestSetup().setUp()
+        # The database should *always* be recreated if a new template had been
+        # chosen.
+        PgTestSetup._last_db = ('different-template', fixture.dbname)
+        fixture.setUp()
         try:
-            con = PgTestSetup().connect()
+            con = fixture.connect()
             cur = con.cursor()
+            # If this fails, TABLE foo still existed and the DB wasn't rebuilt
+            # correctly.
             cur.execute('CREATE TABLE foo (x int)')
             con.commit()
         finally:
-            PgTestSetup().tearDown()
+            fixture.tearDown()
 
     def test_sequences(self):
         # Sequences may be affected by connections even if the connection
@@ -80,9 +87,10 @@
         # the sequences.
 
         # Setup a table that uses a sequence
-        PgTestSetup().setUp()
+        fixture = PgTestSetup()
+        fixture.setUp()
         try:
-            con = PgTestSetup().connect()
+            con = fixture.connect()
             cur = con.cursor()
             cur.execute('CREATE TABLE foo (x serial, y integer)')
             con.commit()
@@ -90,15 +98,15 @@
             # Fake it so the harness doesn't know a change has been made
             ConnectionWrapper.committed = False
         finally:
-            PgTestSetup().tearDown()
+            fixture.tearDown()
 
         sequence_values = []
         # Insert a row into it and roll back the changes. Each time, we
         # should end up with the same sequence value
         for i in range(3):
-            PgTestSetup().setUp()
+            fixture.setUp()
             try:
-                con = PgTestSetup().connect()
+                con = fixture.connect()
                 cur = con.cursor()
                 cur.execute('INSERT INTO foo (y) VALUES (1)')
                 cur.execute("SELECT currval('foo_x_seq')")
@@ -106,7 +114,7 @@
                 con.rollback()
                 con.close()
             finally:
-                PgTestSetup().tearDown()
+                fixture.tearDown()
 
         # Fail if we got a diffent sequence value at some point
         for v in sequence_values:
@@ -114,9 +122,9 @@
 
         # Repeat the test, but this time with some data already in the
         # table
-        PgTestSetup().setUp()
+        fixture.setUp()
         try:
-            con = PgTestSetup().connect()
+            con = fixture.connect()
             cur = con.cursor()
             cur.execute('INSERT INTO foo (y) VALUES (1)')
             con.commit()
@@ -124,15 +132,15 @@
             # Fake it so the harness doesn't know a change has been made
             ConnectionWrapper.committed = False
         finally:
-            PgTestSetup().tearDown()
+            fixture.tearDown()
 
         sequence_values = []
         # Insert a row into it and roll back the changes. Each time, we
         # should end up with the same sequence value
         for i in range(1,3):
-            PgTestSetup().setUp()
+            fixture.setUp()
             try:
-                con = PgTestSetup().connect()
+                con = fixture.connect()
                 cur = con.cursor()
                 cur.execute('INSERT INTO foo (y) VALUES (1)')
                 cur.execute("SELECT currval('foo_x_seq')")
@@ -140,19 +148,8 @@
                 con.rollback()
                 con.close()
             finally:
-                PgTestSetup().tearDown()
+                fixture.tearDown()
 
         # Fail if we got a diffent sequence value at some point
         for v in sequence_values:
             self.failUnlessEqual(v, sequence_values[0])
-
-
-def test_suite():
-    suite = unittest.TestSuite()
-    suite.addTest(unittest.makeSuite(TestPgTestCase))
-    suite.addTest(unittest.makeSuite(TestOptimization))
-    return suite
-
-if __name__ == '__main__':
-    unittest.main()
-

=== modified file 'lib/canonical/launchpad/doc/canonical-config.txt'
--- lib/canonical/launchpad/doc/canonical-config.txt	2010-01-05 19:09:58 +0000
+++ lib/canonical/launchpad/doc/canonical-config.txt	2010-10-17 19:12:52 +0000
@@ -14,8 +14,10 @@
 simple configuration).
 
     >>> from canonical.config import config
-    >>> print config.database.rw_main_master
-    dbname=launchpad_ftest
+    >>> from canonical.testing.layers import DatabaseLayer
+    >>> expected = 'dbname=%s' % DatabaseLayer._db_fixture.dbname
+    >>> expected == config.database.rw_main_master
+    True
     >>> config.database.db_statement_timeout is None
     True
     >>> config.launchpad.dbuser
@@ -226,7 +228,7 @@
 #    >>> canonical.config.config = config
 #    >>> config.filename
 #    '.../configs/testrunner/launchpad-lazr.conf'
-#    >>> config.dbname
-#    'launchpad_ftest'
+#    >>> config.dbname == DatabaseLayer._db_fixture.dbname
+#    True
 #    >>> config._cache.testrunner
 #    <SectionValue for canonical 'testrunner'>

=== modified file 'lib/canonical/launchpad/doc/old-testing.txt'
--- lib/canonical/launchpad/doc/old-testing.txt	2010-10-03 20:23:37 +0000
+++ lib/canonical/launchpad/doc/old-testing.txt	2010-10-17 19:12:52 +0000
@@ -18,11 +18,6 @@
 zope, we should not be testing it with the full Z3 functional test
 harness).
 
-If you are wondering why we use `PgTestSetup().setUp()` and
-`PgTestSetup.tearDown()` instead of `pgtestsetup.setUp()` or
-`pgtestsetup.tearDown()`, it is because I'm mirroring the design used in
-Zope3's `FunctionalTestSetup`.
-
 canonical.functional.FunctionalTestCase
 ---------------------------------------
 
@@ -42,11 +37,12 @@
 
 The setup procedure builds us a fresh, empty database
 
->>> PgTestSetup().setUp()
+>>> fixture = PgTestSetup()
+>>> fixture.setUp()
 
 We can get connections to this database
 
->>> connection = PgTestSetup().connect()
+>>> connection = fixture.connect()
 >>> cursor = connection.cursor()
 >>> cursor.execute("""CREATE TABLE Beer (
 ...     id serial PRIMARY KEY, name text, stamp timestamp without time zone
@@ -68,28 +64,29 @@
 When we have finished, we need to call the tearDown method which closes
 all outstanding connections and destroys the database
 
->>> PgTestSetup().tearDown()
+>>> fixture.tearDown()
 
 Because the database has been destroyed, further tests will not be
 affected.
 
->>> PgTestSetup().setUp()
->>> connection = PgTestSetup().connect()
+>>> fixture.setUp()
+>>> connection = fixture.connect()
 >>> cursor = connection.cursor()
 >>> cursor.execute("CREATE TABLE Beer (id serial PRIMARY KEY, name text)")
->>> PgTestSetup().tearDown()
+>>> fixture.tearDown()
 
 We can also specify a different template to duplicate than the default
 clean one (template1). For example, if you need a launchpad database
 containing no data, you can use `launchpad_empty` as the template.
 
->>> PgTestSetup('launchpad_empty').setUp()
->>> connection = PgTestSetup().connect()
+>>> fixture = PgTestSetup('launchpad_empty')
+>>> fixture.setUp()
+>>> connection = fixture.connect()
 >>> cursor = connection.cursor()
 >>> cursor.execute("SELECT COUNT(*) FROM Person")
 >>> int(cursor.fetchone()[0])
 0
->>> PgTestSetup().tearDown()
+>>> fixture.tearDown()
 
 We can also specify the user that we connect as to avoid connecting as the
 PostgreSQL default user.
@@ -108,14 +105,12 @@
 ------------------
 
 LaunchpadTestSetup is identical to PgTestSetup, except that it creates a
-fresh copy of the Launchpad database filled with our sample data. This
-class is defined in canonical.launchpad.ftests.harness.
-
-Note that at this level, you cannot access any of the SQLBase objects
-
->>> from canonical.launchpad.ftests.harness import LaunchpadTestSetup
->>> LaunchpadTestSetup().setUp()
->>> connection = LaunchpadTestSetup().connect()
+fresh copy of the Launchpad database filled with our sample data.
+
+>>> from canonical.testing.layers import LaunchpadTestSetup
+>>> fixture = LaunchpadTestSetup()
+>>> fixture.setUp()
+>>> connection = fixture.connect()
 >>> cursor = connection.cursor()
 >>> cursor.execute("SELECT displayname FROM person WHERE name='carlos'")
 >>> cursor.fetchone()[0]
@@ -127,7 +122,7 @@
 >>> cursor.fetchone()[0]
 u'launchpad'
 
->>> LaunchpadTestSetup().tearDown()
+>>> fixture.tearDown()
 
 You can connect as a different database user using the same mechanism
 described above for PgTestSetup
@@ -143,114 +138,13 @@
 >>> lpsetup.tearDown()
 
 
-LaunchpadZopelessTestSetup
---------------------------
-
-LaunchpadZopelessTestSetup builds on LaunchpadTestSetup, calling
-initZopeless for you so you can access the SQLBase objects without needing
-the Zope3 infrastructure.
-
->>> from canonical.launchpad.ftests.harness import LaunchpadZopelessTestSetup
->>> LaunchpadZopelessTestSetup().setUp()
->>> from lp.registry.model.person import Person
->>> stub = Person.byName('stub')
->>> stub.displayname
-u'Stuart Bishop'
->>> stub.displayname = u'The Walrus'
->>> stub.displayname
-u'The Walrus'
-
-You have access to the zopeless transaction
-
->>> LaunchpadZopelessTestSetup().txn.abort()
->>> stub.displayname
-u'Stuart Bishop'
-
-And always remember to tearDown or you will victimize other tests!
-
->>> LaunchpadZopelessTestSetup().tearDown()
-
-
-In general, Zopeless tests should never be running as the launchpad user.
-You can select the user you connect as:
-
->>> setup = LaunchpadZopelessTestSetup(dbuser=config.librarian.dbuser)
->>> setup.setUp()
->>> from lp.registry.model.sourcepackagename import SourcePackageName
->>> SourcePackageName.get(1).name
-Traceback (most recent call last):
-...
-ProgrammingError: permission denied for relation sourcepackagename
-<BLANKLINE>
->>> setup.tearDown()
-
-
-LaunchpadFunctionalTestSetup
-----------------------------
-
-One with the lot. A LaunchpadTestSetup which also loads in the Zope3
-environment.
-
->>> from canonical.launchpad.ftests.harness import LaunchpadFunctionalTestSetup
->>> LaunchpadFunctionalTestSetup().setUp()
-
-You have full access to the SQLBase objects
-
->>> mark = Person.byName('mark')
->>> mark.displayname
-u'Mark Shuttleworth'
-
-You also have access to the Zope3 component architecture, as registered
-by ftesting.zcml
-
->>> from zope.app import zapi
->>> from zope.sendmail.interfaces import IMailer
->>> zapi.getUtility(IMailer, 'smtp') is not None
-True
-
->>> LaunchpadFunctionalTestSetup().tearDown()
-
-You can change the user that the tests connect as:
-
-  XXX 2008-05-29 jamesh:
-  Using LaunchpadFunctionalLayer for non-webapp db users is generally
-  a sign of a bug.  These bits of code should generally be using
-  LaunchpadZopelessLayer.
-
-##>>> setup = LaunchpadFunctionalTestSetup(dbuser=config.librarian.dbuser)
-##>>> setup.setUp()
-##>>> connection = setup.connect()
-##>>> cursor = connection.cursor()
-##>>> cursor.execute('SELECT current_user')
-##>>> cursor.fetchone()[0]
-##u'librarian'
-##>>> SourcePackageName.get(1).name
-##Traceback (most recent call last):
-##...
-##ProgrammingError: permission denied ...
-##>>> setup.tearDown()
-
-And the next test will be unaffected:
-
->>> setup = LaunchpadFunctionalTestSetup()
->>> setup.setUp()
->>> connection = setup.connect()
->>> cursor = connection.cursor()
->>> cursor.execute('SELECT current_user')
->>> cursor.fetchone()[0]
-u'launchpad'
->>> SourcePackageName.get(1).name
-u'mozilla-firefox'
->>> setup.tearDown()
-
-
 LibrarianTestSetup
 ------------------
 
 Code that needs to access the Librarian can do so easily. Note that
 LibrarianTestSetup requires the Launchpad database to be available, and
 thus requires LaunchpadTestSetup or similar to be used in tandam.
-You probably really want LaunchpadFunctionalTestSetup so you can access
+You probably really want LaunchpadFunctionalLayer so you can access
 the Librarian as a Utility.
 
 >>> from canonical.librarian.testing.server import LibrarianTestSetup
@@ -259,7 +153,6 @@
 >>> from canonical.librarian.interfaces import ILibrarianClient
 >>> from StringIO import StringIO
 
->>> LaunchpadFunctionalTestSetup().setUp()
 >>> librarian = LibrarianTestSetup()
 >>> librarian.setUp()
 >>> login(ANONYMOUS)
@@ -285,7 +178,6 @@
 True
 
 >>> librarian.tearDown()
->>> LaunchpadFunctionalTestSetup().tearDown()
 
 >>> from canonical.testing import reset_logging
 >>> reset_logging()

=== modified file 'lib/canonical/launchpad/doc/security-proxies.txt'
--- lib/canonical/launchpad/doc/security-proxies.txt	2010-10-09 16:36:22 +0000
+++ lib/canonical/launchpad/doc/security-proxies.txt	2010-10-17 19:12:52 +0000
@@ -6,13 +6,10 @@
 
 First, some imports and set up::
 
-    >>> from canonical.launchpad.ftests.harness import LaunchpadFunctionalTestSetup
     >>> from zope.component import getUtility
     >>> from lp.registry.interfaces.person import IPersonSet
     >>> from lp.registry.model.person import Person
 
-    >>> LaunchpadFunctionalTestSetup().setUp()
-
 Get a proxied and unproxied person object for the same person, and demonstrate
 working comparisons::
 
@@ -57,8 +54,3 @@
     True
     >>> hoary.status is SeriesStatus.DEVELOPMENT
     False
-
-Finally, tear down the test:
-
-    >>> LaunchpadFunctionalTestSetup().tearDown()
-

=== removed file 'lib/canonical/launchpad/ftests/harness.py'
--- lib/canonical/launchpad/ftests/harness.py	2010-10-04 19:50:45 +0000
+++ lib/canonical/launchpad/ftests/harness.py	1970-01-01 00:00:00 +0000
@@ -1,84 +0,0 @@
-# Copyright 2009 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-"""
-Launchpad functional test helpers.
-
-This file needs to be refactored, moving its functionality into
-canonical.testing
-"""
-
-__metaclass__ = type
-
-
-from zope.app.testing.functional import FunctionalTestSetup
-
-from canonical.database.sqlbase import ZopelessTransactionManager
-from canonical.ftests.pgsql import PgTestSetup
-from canonical.lp import initZopeless
-from canonical.testing.layers import (
-    FunctionalLayer,
-    ZopelessLayer,
-    )
-from canonical.testing.layers import (
-    disconnect_stores,
-    reconnect_stores,
-    )
-
-
-__all__ = [
-    'LaunchpadTestSetup', 'LaunchpadZopelessTestSetup',
-    'LaunchpadFunctionalTestSetup',
-    ]
-
-
-class LaunchpadTestSetup(PgTestSetup):
-    template = 'launchpad_ftest_template'
-    dbname = 'launchpad_ftest' # Needs to match ftesting.zcml
-    dbuser = 'launchpad'
-
-
-class LaunchpadZopelessTestSetup(LaunchpadTestSetup):
-    txn = ZopelessTransactionManager
-    def setUp(self, dbuser=None):
-        assert ZopelessTransactionManager._installed is None, \
-                'Last test using Zopeless failed to tearDown correctly'
-        super(LaunchpadZopelessTestSetup, self).setUp()
-        if self.host is not None:
-            raise NotImplementedError('host not supported yet')
-        if self.port is not None:
-            raise NotImplementedError('port not supported yet')
-        if dbuser is not None:
-            self.dbuser = dbuser
-        initZopeless(dbname=self.dbname, dbuser=self.dbuser)
-
-    def tearDown(self):
-        LaunchpadZopelessTestSetup.txn.uninstall()
-        assert ZopelessTransactionManager._installed is None, \
-                'Failed to tearDown Zopeless correctly'
-
-
-class LaunchpadFunctionalTestSetup(LaunchpadTestSetup):
-    def _checkLayerInvariants(self):
-        assert FunctionalLayer.isSetUp or ZopelessLayer.isSetUp, """
-                FunctionalTestSetup invoked at an inappropriate time.
-                May only be invoked in the FunctionalLayer or ZopelessLayer
-                """
-
-    def setUp(self, dbuser=None):
-        self._checkLayerInvariants()
-        if dbuser is not None:
-            self.dbuser = dbuser
-        assert self.dbuser == 'launchpad', (
-            "Non-default user names should probably be using "
-            "script layer or zopeless layer.")
-        disconnect_stores()
-        super(LaunchpadFunctionalTestSetup, self).setUp()
-        FunctionalTestSetup().setUp()
-        reconnect_stores()
-
-    def tearDown(self):
-        self._checkLayerInvariants()
-        FunctionalTestSetup().tearDown()
-        disconnect_stores()
-        super(LaunchpadFunctionalTestSetup, self).tearDown()

=== modified file 'lib/canonical/launchpad/pagetests/standalone/xx-dbpolicy.txt'
--- lib/canonical/launchpad/pagetests/standalone/xx-dbpolicy.txt	2010-01-13 13:50:39 +0000
+++ lib/canonical/launchpad/pagetests/standalone/xx-dbpolicy.txt	2010-10-17 19:12:52 +0000
@@ -20,9 +20,11 @@
     >>> from zope.component import getUtility
     >>> from canonical.launchpad.webapp.interfaces import (
     ...     IStoreSelector, MAIN_STORE, MASTER_FLAVOR, SLAVE_FLAVOR)
+    >>> from canonical.testing.layers import DatabaseLayer
     >>> master = getUtility(IStoreSelector).get(MAIN_STORE, MASTER_FLAVOR)
-    >>> master.execute("SELECT current_database()").get_one()[0]
-    u'launchpad_ftest'
+    >>> dbname = DatabaseLayer._db_fixture.dbname
+    >>> dbname == master.execute("SELECT current_database()").get_one()[0]
+    True
     >>> slave = getUtility(IStoreSelector).get(MAIN_STORE, SLAVE_FLAVOR)
     >>> slave.execute("SELECT current_database()").get_one()[0]
     u'launchpad_empty'
@@ -47,7 +49,7 @@
 
     >>> def whichdb(browser):
     ...     dbname = extract_text(find_tag_by_id(browser.contents, 'dbname'))
-    ...     if dbname == 'launchpad_ftest':
+    ...     if dbname == DatabaseLayer._db_fixture.dbname:
     ...         return 'MASTER'
     ...     elif dbname == 'launchpad_empty':
     ...         return 'SLAVE'

=== modified file 'lib/canonical/launchpad/tests/test_sampledata.py'
--- lib/canonical/launchpad/tests/test_sampledata.py	2010-09-22 13:26:50 +0000
+++ lib/canonical/launchpad/tests/test_sampledata.py	2010-10-17 19:12:52 +0000
@@ -12,7 +12,6 @@
 __all__ = []
 
 import subprocess
-import unittest
 
 from canonical.testing.layers import DatabaseLayer
 from lp.testing import TestCase
@@ -37,14 +36,11 @@
         cmd = (
             "pg_dump --format=c --compress=0 --no-privileges --no-owner"
             " --schema=public %s | pg_restore --clean"
-            " --exit-on-error --dbname=launchpad_ftest" % source_dbname)
+            " --exit-on-error --dbname=%s" % (
+            source_dbname, DatabaseLayer._db_fixture.dbname))
         proc = subprocess.Popen(
             cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
             stdin=subprocess.PIPE)
         (stdout, stderr) = proc.communicate()
         rv = proc.wait()
         self.failUnlessEqual(rv, 0, "Dump/Restore failed: %s" % stdout)
-
-
-def test_suite():
-    return unittest.TestLoader().loadTestsFromName(__name__)

=== modified file 'lib/canonical/launchpad/webapp/ftests/test_adapter.txt'
--- lib/canonical/launchpad/webapp/ftests/test_adapter.txt	2010-09-17 00:53:33 +0000
+++ lib/canonical/launchpad/webapp/ftests/test_adapter.txt	2010-10-17 19:12:52 +0000
@@ -18,14 +18,18 @@
     >>> from canonical.launchpad.webapp.adapter import (
     ...     clear_request_started, get_request_statements,
     ...     set_request_started)
+    >>> from canonical.testing.layers import DatabaseLayer
     >>> from lp.services.timeline.requesttimeline import get_request_timeline
 
 There are several possible database connections available via the
 IStoreSelector utility.
 
     >>> store = getUtility(IStoreSelector).get(MAIN_STORE, MASTER_FLAVOR)
-    >>> print store.execute("SELECT current_database()").get_one()[0]
-    launchpad_ftest
+    >>> dbname = DatabaseLayer._db_fixture.dbname
+    >>> active_name = store.execute("SELECT current_database()").get_one()[0]
+    >>> if active_name != dbname: print '%s != %s' % (active_name, dbname)
+    >>> active_name == dbname
+    True
 
 
 Statement Logging

=== modified file 'lib/canonical/lp/ftests/test_zopeless.py'
--- lib/canonical/lp/ftests/test_zopeless.py	2010-10-04 19:50:45 +0000
+++ lib/canonical/lp/ftests/test_zopeless.py	2010-10-17 19:12:52 +0000
@@ -14,9 +14,11 @@
 from sqlobject import StringCol, IntCol
 
 from canonical.database.sqlbase import SQLBase, alreadyInstalledMsg, cursor
-from canonical.ftests.pgsql import PgTestSetup
 from canonical.lp import initZopeless
-from canonical.testing.layers import LaunchpadScriptLayer
+from canonical.testing.layers import (
+    DatabaseLayer,
+    LaunchpadScriptLayer,
+    )
 
 
 class MoreBeer(SQLBase):
@@ -28,6 +30,7 @@
 
 
 class TestInitZopeless(unittest.TestCase):
+
     layer = LaunchpadScriptLayer
 
     def test_initZopelessTwice(self):
@@ -47,10 +50,11 @@
             # Calling initZopeless with the same arguments twice should return
             # the exact same object twice, but also emit a warning.
             try:
-                tm1 = initZopeless(dbname=PgTestSetup().dbname, dbhost='',
-                        dbuser='launchpad')
-                tm2 = initZopeless(dbname=PgTestSetup().dbname, dbhost='',
-                        dbuser='launchpad')
+                dbname = DatabaseLayer._db_fixture.dbname
+                tm1 = initZopeless(
+                    dbname=dbname, dbhost='', dbuser='launchpad')
+                tm2 = initZopeless(
+                    dbname=dbname, dbhost='', dbuser='launchpad')
                 self.failUnless(tm1 is tm2)
                 self.failUnless(self.warned)
             finally:
@@ -65,10 +69,11 @@
 
 
 class TestZopeless(unittest.TestCase):
+
     layer = LaunchpadScriptLayer
 
     def setUp(self):
-        self.tm = initZopeless(dbname=PgTestSetup().dbname,
+        self.tm = initZopeless(dbname=DatabaseLayer._db_fixture.dbname,
                                dbuser='launchpad')
 
         c = cursor()
@@ -182,7 +187,7 @@
         self.tm.commit()
 
         # Make another change from a non-SQLObject connection, and commit that
-        conn = psycopg2.connect('dbname=' + PgTestSetup().dbname)
+        conn = psycopg2.connect('dbname=' + DatabaseLayer._db_fixture.dbname)
         cur = conn.cursor()
         cur.execute("BEGIN TRANSACTION;")
         cur.execute("UPDATE MoreBeer SET rating=4 "
@@ -202,7 +207,7 @@
     >>> isZopeless()
     False
 
-    >>> tm = initZopeless(dbname=PgTestSetup().dbname,
+    >>> tm = initZopeless(dbname=DatabaseLayer._db_fixture.dbname,
     ...     dbhost='', dbuser='launchpad')
     >>> isZopeless()
     True

=== modified file 'lib/canonical/testing/ftests/test_layers.py'
--- lib/canonical/testing/ftests/test_layers.py	2010-07-26 13:18:18 +0000
+++ lib/canonical/testing/ftests/test_layers.py	2010-10-17 19:12:52 +0000
@@ -20,16 +20,27 @@
 from zope.component import getUtility, ComponentLookupError
 
 from canonical.config import config, dbconfig
-from canonical.launchpad.ftests.harness import LaunchpadTestSetup
 from lazr.config import as_host_port
 from canonical.librarian.client import LibrarianClient, UploadFailed
 from canonical.librarian.interfaces import ILibrarianClient
 from canonical.lazr.pidfile import pidfile_path
 from canonical.testing.layers import (
-    AppServerLayer, BaseLayer, DatabaseLayer, FunctionalLayer,
-    LaunchpadFunctionalLayer, LaunchpadLayer, LaunchpadScriptLayer,
-    LaunchpadZopelessLayer, LayerInvariantError, LayerIsolationError,
-    LayerProcessController, LibrarianLayer, MemcachedLayer, ZopelessLayer)
+    AppServerLayer,
+    BaseLayer,
+    DatabaseLayer,
+    FunctionalLayer,
+    LaunchpadFunctionalLayer,
+    LaunchpadLayer,
+    LaunchpadScriptLayer,
+    LaunchpadTestSetup,
+    LaunchpadZopelessLayer,
+    LayerInvariantError,
+    LayerIsolationError,
+    LayerProcessController,
+    LibrarianLayer,
+    MemcachedLayer,
+    ZopelessLayer,
+    )
 from lp.services.memcache.client import memcache_client_factory
 
 class BaseTestCase(unittest.TestCase):
@@ -123,22 +134,13 @@
                     )
 
     def testLaunchpadDbAvailable(self):
-        try:
-            con = DatabaseLayer.connect()
-            cur = con.cursor()
-            cur.execute("SELECT id FROM Person LIMIT 1")
-            if cur.fetchone() is not None:
-                self.failUnless(
-                        self.want_launchpad_database,
-                        'Launchpad database should not be available.'
-                        )
-                return
-        except psycopg2.Error:
-            pass
-        self.failIf(
-                self.want_launchpad_database,
-                'Launchpad database should be available but is not.'
-                )
+        if not self.want_launchpad_database:
+            self.assertEqual(None, DatabaseLayer._db_fixture)
+            return
+        con = DatabaseLayer.connect()
+        cur = con.cursor()
+        cur.execute("SELECT id FROM Person LIMIT 1")
+        self.assertNotEqual(None, cur.fetchone())
 
     def testMemcachedWorking(self):
         client = MemcachedLayer.client or memcache_client_factory()
@@ -424,6 +426,9 @@
         # The database should be reset by the test invariants.
         LayerProcessController.startAppServer()
         LayerProcessController.postTestInvariants()
+        # XXX: Robert Collins 2010-10-17 bug=661967 - this isn't a reset, its
+        # a flag that it *needs* a reset, which is actually quite different;
+        # the lack of a teardown will leak daabases.
         self.assertEquals(True, LaunchpadTestSetup()._reset_db)
 
 

=== modified file 'lib/canonical/testing/layers.py'
--- lib/canonical/testing/layers.py	2010-10-05 13:25:01 +0000
+++ lib/canonical/testing/layers.py	2010-10-17 19:12:52 +0000
@@ -35,6 +35,7 @@
     'LaunchpadFunctionalLayer',
     'LaunchpadLayer',
     'LaunchpadScriptLayer',
+    'LaunchpadTestSetup',
     'LaunchpadZopelessLayer',
     'LayerInvariantError',
     'LayerIsolationError',
@@ -92,6 +93,7 @@
 from zope.server.logger.pythonlogger import PythonLogger
 from zope.testing.testrunner.runner import FakeInputContinueGenerator
 
+from canonical.ftests.pgsql import PgTestSetup
 from canonical.launchpad.webapp.vhosts import allvhosts
 from canonical.lazr import pidfile
 from canonical.config import CanonicalConfig, config, dbconfig
@@ -264,12 +266,14 @@
         if not BaseLayer.persist_test_services:
             kill_by_pidfile(MemcachedLayer.getPidFile(), num_polls=0)
         # Kill any database left lying around from a previous test run.
+        db_fixture = LaunchpadTestSetup()
         try:
-            DatabaseLayer.connect().close()
+            db_fixture.connect().close()
         except psycopg2.Error:
+            # We assume this means 'no test database exists.'
             pass
         else:
-            DatabaseLayer._dropDb()
+            db_fixture.dropDb()
 
     @classmethod
     @profiled
@@ -693,19 +697,19 @@
     _reset_between_tests = True
 
     _is_setup = False
+    _db_fixture = None
 
     @classmethod
     @profiled
     def setUp(cls):
         cls._is_setup = True
-        DatabaseLayer.force_dirty_database()
-        # Imported here to avoid circular import issues. This
-        # functionality should be migrated into this module at some
-        # point. -- StuartBishop 20060712
-        from canonical.launchpad.ftests.harness import LaunchpadTestSetup
-        LaunchpadTestSetup().tearDown()
-        DatabaseLayer._reset_sequences_sql = LaunchpadTestSetup(
+        # Read the sequences we'll need from the test template database.
+        reset_sequences_sql = LaunchpadTestSetup(
             dbname='launchpad_ftest_template').generateResetSequencesSQL()
+        cls._db_fixture = LaunchpadTestSetup(
+            reset_sequences_sql=reset_sequences_sql)
+        cls.force_dirty_database()
+        cls._db_fixture.tearDown()
 
     @classmethod
     @profiled
@@ -716,32 +720,22 @@
         # Don't leave the DB lying around or it might break tests
         # that depend on it not being there on startup, such as found
         # in test_layers.py
-        DatabaseLayer.force_dirty_database()
-        # Imported here to avoid circular import issues. This
-        # functionality should be migrated into this module at some
-        # point. -- StuartBishop 20060712
-        from canonical.launchpad.ftests.harness import LaunchpadTestSetup
-        LaunchpadTestSetup().tearDown()
-        DatabaseLayer._reset_sequences_sql = None
+        cls.force_dirty_database()
+        cls._db_fixture.tearDown()
+        cls._db_fixture = None
 
     @classmethod
     @profiled
     def testSetUp(cls):
-        # Imported here to avoid circular import issues. This
-        # functionality should be migrated into this module at some
-        # point. -- StuartBishop 20060712
-        from canonical.launchpad.ftests.harness import LaunchpadTestSetup
-        if DatabaseLayer._reset_between_tests:
-            LaunchpadTestSetup(
-                reset_sequences_sql=DatabaseLayer._reset_sequences_sql
-                ).setUp()
+        if cls._reset_between_tests:
+            cls._db_fixture.setUp()
         # Ensure that the database is connectable. Because we might have
         # just created it, keep trying for a few seconds incase PostgreSQL
         # is taking its time getting its house in order.
         attempts = 60
         for count in range(0, attempts):
             try:
-                DatabaseLayer.connect().close()
+                cls.connect().close()
             except psycopg2.Error:
                 if count == attempts - 1:
                     raise
@@ -749,24 +743,20 @@
             else:
                 break
 
-        if DatabaseLayer.use_mockdb is True:
-            DatabaseLayer.installMockDb()
+        if cls.use_mockdb is True:
+            cls.installMockDb()
 
     @classmethod
     @profiled
     def testTearDown(cls):
-        if DatabaseLayer.use_mockdb is True:
-            DatabaseLayer.uninstallMockDb()
+        if cls.use_mockdb is True:
+            cls.uninstallMockDb()
 
         # Ensure that the database is connectable
-        DatabaseLayer.connect().close()
+        cls.connect().close()
 
-        # Imported here to avoid circular import issues. This
-        # functionality should be migrated into this module at some
-        # point. -- StuartBishop 20060712
-        from canonical.launchpad.ftests.harness import LaunchpadTestSetup
-        if DatabaseLayer._reset_between_tests:
-            LaunchpadTestSetup().tearDown()
+        if cls._reset_between_tests:
+            cls._db_fixture.tearDown()
 
         # Fail tests that forget to uninstall their database policies.
         from canonical.launchpad.webapp.adapter import StoreSelector
@@ -781,7 +771,7 @@
     @classmethod
     @profiled
     def installMockDb(cls):
-        assert DatabaseLayer.mockdb_mode is None, 'mock db already installed'
+        assert cls.mockdb_mode is None, 'mock db already installed'
 
         from canonical.testing.mockdb import (
                 script_filename, ScriptRecorder, ScriptPlayer,
@@ -795,32 +785,32 @@
         # mock db script.
         filename = script_filename(test_key)
         if os.path.exists(filename):
-            DatabaseLayer.mockdb_mode = 'replay'
-            DatabaseLayer.script = ScriptPlayer(test_key)
+            cls.mockdb_mode = 'replay'
+            cls.script = ScriptPlayer(test_key)
         else:
-            DatabaseLayer.mockdb_mode = 'record'
-            DatabaseLayer.script = ScriptRecorder(test_key)
+            cls.mockdb_mode = 'record'
+            cls.script = ScriptRecorder(test_key)
 
         global _org_connect
         _org_connect = psycopg2.connect
         # Proxy real connections with our mockdb.
         def fake_connect(*args, **kw):
-            return DatabaseLayer.script.connect(_org_connect, *args, **kw)
+            return cls.script.connect(_org_connect, *args, **kw)
         psycopg2.connect = fake_connect
 
     @classmethod
     @profiled
     def uninstallMockDb(cls):
-        if DatabaseLayer.mockdb_mode is None:
+        if cls.mockdb_mode is None:
             return # Already uninstalled
 
         # Store results if we are recording
-        if DatabaseLayer.mockdb_mode == 'record':
-            DatabaseLayer.script.store()
-            assert os.path.exists(DatabaseLayer.script.script_filename), (
+        if cls.mockdb_mode == 'record':
+            cls.script.store()
+            assert os.path.exists(cls.script.script_filename), (
                     "Stored results but no script on disk.")
 
-        DatabaseLayer.mockdb_mode = None
+        cls.mockdb_mode = None
         global _org_connect
         psycopg2.connect = _org_connect
         _org_connect = None
@@ -828,20 +818,17 @@
     @classmethod
     @profiled
     def force_dirty_database(cls):
-        from canonical.launchpad.ftests.harness import LaunchpadTestSetup
-        LaunchpadTestSetup().force_dirty_database()
+        cls._db_fixture.force_dirty_database()
 
     @classmethod
     @profiled
     def connect(cls):
-        from canonical.launchpad.ftests.harness import LaunchpadTestSetup
-        return LaunchpadTestSetup().connect()
+        return cls._db_fixture.connect()
 
     @classmethod
     @profiled
     def _dropDb(cls):
-        from canonical.launchpad.ftests.harness import LaunchpadTestSetup
-        return LaunchpadTestSetup().dropDb()
+        return cls._db_fixture.dropDb()
 
 
 def test_default_timeout():
@@ -1378,6 +1365,11 @@
         reconnect_stores(database_config_section=database_config_section)
 
 
+class LaunchpadTestSetup(PgTestSetup):
+    template = 'launchpad_ftest_template'
+    dbuser = 'launchpad'
+
+
 class LaunchpadZopelessLayer(LaunchpadScriptLayer):
     """Full Zopeless environment including Component Architecture and
     database connections initialized.
@@ -1643,6 +1635,9 @@
     # configs/testrunner-appserver/mail-configure.zcml
     smtp_controller = None
 
+    # The DB fixture in use
+    _db_fixture = None
+
     @classmethod
     @profiled
     def startSMTPServer(cls):
@@ -1770,9 +1765,12 @@
     @classmethod
     def _runAppServer(cls):
         """Start the app server using runlaunchpad.py"""
-        from canonical.launchpad.ftests.harness import LaunchpadTestSetup
         # The database must be available for the app server to start.
-        LaunchpadTestSetup().setUp()
+        cls._db_fixture = LaunchpadTestSetup()
+        # This is not torn down properly: rather the singleton nature is abused
+        # and the fixture is simply marked as being dirty.
+        # XXX: Robert Collins 2010-10-17 bug=661967
+        cls._db_fixture.setUp()
         # The app server will not start at all if the database hasn't been
         # correctly patched. The app server will make exactly this check,
         # doing it here makes the error more obvious.

=== modified file 'lib/lp/codehosting/tests/test_acceptance.py'
--- lib/lp/codehosting/tests/test_acceptance.py	2010-10-04 19:50:45 +0000
+++ lib/lp/codehosting/tests/test_acceptance.py	2010-10-17 19:12:52 +0000
@@ -21,7 +21,6 @@
 from zope.component import getUtility
 
 from canonical.config import config
-from canonical.launchpad.ftests.harness import LaunchpadZopelessTestSetup
 from canonical.testing.layers import ZopelessAppServerLayer
 from canonical.testing.profiled import profiled
 from lp.code.bzr import (
@@ -334,7 +333,7 @@
         remote_url = self.getTransportURL('~testuser/+junk/test-branch')
         self.push(self.local_branch_path, remote_url)
         self.assertBranchesMatch(self.local_branch_path, remote_url)
-        LaunchpadZopelessTestSetup().txn.begin()
+        ZopelessAppServerLayer.txn.begin()
         db_branch = getUtility(IBranchSet).getByUniqueName(
             '~testuser/+junk/test-branch')
         self.assertEqual(
@@ -343,7 +342,7 @@
             BranchFormat.BZR_BRANCH_7, db_branch.branch_format)
         self.assertEqual(
             ControlFormat.BZR_METADIR_1, db_branch.control_format)
-        LaunchpadZopelessTestSetup().txn.commit()
+        ZopelessAppServerLayer.txn.commit()
 
     def test_push_to_existing_branch(self):
         """Pushing to an existing branch must work."""
@@ -374,12 +373,12 @@
         self.push(self.local_branch_path, remote_url)
 
         # Rename owner, product and branch in the database
-        LaunchpadZopelessTestSetup().txn.begin()
+        ZopelessAppServerLayer.txn.begin()
         branch = self.getDatabaseBranch('testuser', None, 'test-branch')
         branch.owner.name = 'renamed-user'
         branch.setTarget(user=branch.owner, project=Product.byName('firefox'))
         branch.name = 'renamed-branch'
-        LaunchpadZopelessTestSetup().txn.commit()
+        ZopelessAppServerLayer.txn.commit()
 
         # Check that it's not at the old location.
         self.assertNotBranch(
@@ -405,23 +404,23 @@
             '~testuser/+junk/totally-new-branch')
         self.push(self.local_branch_path, remote_url)
 
-        LaunchpadZopelessTestSetup().txn.begin()
+        ZopelessAppServerLayer.txn.begin()
         branch = self.getDatabaseBranch(
             'testuser', None, 'totally-new-branch')
 
         self.assertEqual(
             ['~testuser/+junk/totally-new-branch', self.revid],
             [branch.unique_name, branch.last_mirrored_id])
-        LaunchpadZopelessTestSetup().txn.abort()
+        ZopelessAppServerLayer.txn.abort()
 
     def test_record_default_stacking(self):
         # If the location being pushed to has a default stacked-on branch,
         # then branches pushed to that location end up stacked on it by
         # default.
         product = self.factory.makeProduct()
-        LaunchpadZopelessTestSetup().txn.commit()
+        ZopelessAppServerLayer.txn.commit()
 
-        LaunchpadZopelessTestSetup().txn.begin()
+        ZopelessAppServerLayer.txn.begin()
 
         self.make_branch_and_tree('stacked-on')
         trunk_unique_name = '~testuser/%s/trunk' % product.name
@@ -431,7 +430,7 @@
         self.factory.enableDefaultStackingForProduct(
             db_trunk.product, db_trunk)
 
-        LaunchpadZopelessTestSetup().txn.commit()
+        ZopelessAppServerLayer.txn.commit()
 
         stacked_unique_name = '~testuser/%s/stacked' % product.name
         self.push(
@@ -447,7 +446,7 @@
         # attribute of the database branch, and stacked on location of the new
         # branch is normalized to be a relative path.
         product = self.factory.makeProduct()
-        LaunchpadZopelessTestSetup().txn.commit()
+        ZopelessAppServerLayer.txn.commit()
 
         self.make_branch_and_tree('stacked-on')
         trunk_unique_name = '~testuser/%s/trunk' % product.name
@@ -507,11 +506,11 @@
     def test_push_to_new_short_branch_alias(self):
         # We can also push branches to URLs like /+branch/firefox
         # Hack 'firefox' so we have permission to do this.
-        LaunchpadZopelessTestSetup().txn.begin()
+        ZopelessAppServerLayer.txn.begin()
         firefox = Product.selectOneBy(name='firefox')
         testuser = Person.selectOneBy(name='testuser')
         firefox.development_focus.owner = testuser
-        LaunchpadZopelessTestSetup().txn.commit()
+        ZopelessAppServerLayer.txn.commit()
         remote_url = self.getTransportURL('+branch/firefox')
         self.push(self.local_branch_path, remote_url)
         self.assertBranchesMatch(self.local_branch_path, remote_url)
@@ -520,10 +519,10 @@
         # If a hosted branch exists in the database, but not on the
         # filesystem, and is writable by the user, then the user is able to
         # push to it.
-        LaunchpadZopelessTestSetup().txn.begin()
+        ZopelessAppServerLayer.txn.begin()
         branch = self.makeDatabaseBranch('testuser', 'firefox', 'some-branch')
         remote_url = self.getTransportURL(branch.unique_name)
-        LaunchpadZopelessTestSetup().txn.commit()
+        ZopelessAppServerLayer.txn.commit()
         self.push(
             self.local_branch_path, remote_url,
             extra_args=['--use-existing-dir'])
@@ -531,21 +530,21 @@
 
     def test_cant_push_to_existing_mirrored_branch(self):
         # Users cannot push to mirrored branches.
-        LaunchpadZopelessTestSetup().txn.begin()
+        ZopelessAppServerLayer.txn.begin()
         branch = self.makeDatabaseBranch(
             'testuser', 'firefox', 'some-branch', BranchType.MIRRORED)
         remote_url = self.getTransportURL(branch.unique_name)
-        LaunchpadZopelessTestSetup().txn.commit()
+        ZopelessAppServerLayer.txn.commit()
         self.assertCantPush(
             self.local_branch_path, remote_url,
             ['Permission denied:', 'Transport operation not possible:'])
 
     def test_cant_push_to_existing_unowned_hosted_branch(self):
         # Users can only push to hosted branches that they own.
-        LaunchpadZopelessTestSetup().txn.begin()
+        ZopelessAppServerLayer.txn.begin()
         branch = self.makeDatabaseBranch('mark', 'firefox', 'some-branch')
         remote_url = self.getTransportURL(branch.unique_name)
-        LaunchpadZopelessTestSetup().txn.commit()
+        ZopelessAppServerLayer.txn.commit()
         self.assertCantPush(
             self.local_branch_path, remote_url,
             ['Permission denied:', 'Transport operation not possible:'])
@@ -566,12 +565,12 @@
             person_name, product_name, branch_name)
 
         # Mark as mirrored.
-        LaunchpadZopelessTestSetup().txn.begin()
+        ZopelessAppServerLayer.txn.begin()
         branch = self.getDatabaseBranch(
             person_name, product_name, branch_name)
         branch.branch_type = BranchType.MIRRORED
         branch.url = "http://example.com/smartservertest/branch"
-        LaunchpadZopelessTestSetup().txn.commit()
+        ZopelessAppServerLayer.txn.commit()
         return ro_branch_url
 
     def test_can_read_readonly_branch(self):

=== modified file 'lib/lp/soyuz/doc/sampledata-setup.txt'
--- lib/lp/soyuz/doc/sampledata-setup.txt	2010-08-13 02:59:14 +0000
+++ lib/lp/soyuz/doc/sampledata-setup.txt	2010-10-17 19:12:52 +0000
@@ -21,5 +21,5 @@
     INFO ...
     INFO Done.
 
-    >>> from canonical.launchpad.ftests.harness import LaunchpadTestSetup
-    >>> LaunchpadTestSetup().force_dirty_database()
+    >>> from canonical.testing.layers import DatabaseLayer
+    >>> DatabaseLayer.force_dirty_database()

=== modified file 'lib/lp/soyuz/scripts/tests/test_buildd_cronscripts.py'
--- lib/lp/soyuz/scripts/tests/test_buildd_cronscripts.py	2010-10-04 19:50:45 +0000
+++ lib/lp/soyuz/scripts/tests/test_buildd_cronscripts.py	2010-10-17 19:12:52 +0000
@@ -74,9 +74,8 @@
         rc, out, err = runner()
         self.assertEqual(0, rc, "Err:\n%s" % err)
 
-        # 'runners' commit to the launchpad_ftest database in
-        # subprocesses, so we need to tell the layer to fully
-        # tear down and restore the database.
+        # 'runners' commit to the test database in subprocesses, so we need to
+        # tell the layer to fully tear down and restore the database.
         DatabaseLayer.force_dirty_database()
 
         return rc, out, err

=== modified file 'lib/lp/translations/doc/fix_translation_credits.txt'
--- lib/lp/translations/doc/fix_translation_credits.txt	2010-04-01 04:05:10 +0000
+++ lib/lp/translations/doc/fix_translation_credits.txt	2010-10-17 19:12:52 +0000
@@ -19,5 +19,5 @@
 After altering the database from a separate process, we must tell the
 test setup that the database is dirty in spite of appearances.
 
-    >>> from canonical.launchpad.ftests.harness import LaunchpadTestSetup
-    >>> LaunchpadTestSetup().force_dirty_database()
+    >>> from canonical.testing.layers import DatabaseLayer
+    >>> DatabaseLayer.force_dirty_database()

=== modified file 'lib/lp/translations/doc/message-sharing-merge-script.txt'
--- lib/lp/translations/doc/message-sharing-merge-script.txt	2009-08-04 13:37:57 +0000
+++ lib/lp/translations/doc/message-sharing-merge-script.txt	2010-10-17 19:12:52 +0000
@@ -20,5 +20,5 @@
 # The script modified the database, even though the database layer may
 # not have noticed it.
 
-    >>> from canonical.launchpad.ftests.harness import LaunchpadTestSetup
-    >>> LaunchpadTestSetup().force_dirty_database()
+    >>> from canonical.testing.layers import DatabaseLayer
+    >>> DatabaseLayer.force_dirty_database()

=== modified file 'lib/lp/translations/doc/request_country.txt'
--- lib/lp/translations/doc/request_country.txt	2010-02-26 21:58:15 +0000
+++ lib/lp/translations/doc/request_country.txt	2010-10-17 19:12:52 +0000
@@ -4,10 +4,6 @@
 
 Adapting a request to a country allows you to see where the request came from.
 
-    >>> from canonical.launchpad.ftests.harness import (
-    ...     LaunchpadFunctionalTestSetup)
-    >>> LaunchpadFunctionalTestSetup().setUp()
-
 Here's a dummy request. Zope adds the REMOTE_ADDR CGI environment variable
 for us. Upstream proxy servers (and tinkering users!) may also add
 X-Forwarded-For: headers. The X-Forwarded-For: header takes precidence
@@ -34,6 +30,3 @@
     Traceback (most recent call last):
     ...
     TypeError: ('Could not adapt', ...
-
-    >>> LaunchpadFunctionalTestSetup().tearDown()
-