Cherry-pick buildbot 95deef27d7c531ead19e0ac86a9aa1546d4ee7f9:

third_party/buildbot_8_4p1/buildbot/test/unit/test_db_pool.py

 # This file is part of Buildbot.  Buildbot is free software: you can
 # redistribute it and/or modify it under the terms of the GNU General Public
 # License as published by the Free Software Foundation, version 2.
 #
 # This program is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 # details.
 #
 # You should have received a copy of the GNU General Public License along with
 # this program; if not, write to the Free Software Foundation, Inc., 51
 # Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #
 # Copyright Buildbot Team Members
 
+import os
+import time
 import sqlalchemy as sa
 from twisted.trial import unittest
-from twisted.internet import defer
+from twisted.internet import defer, reactor
 from buildbot.db import pool
 from buildbot.test.util import db
 
 class Basic(unittest.TestCase):
 
     # basic tests, just using an in-memory SQL db and one thread
 
     def setUp(self):
         self.engine = sa.create_engine('sqlite://')
         self.engine.optimal_thread_pool_size = 1
@@ skipping 67 matching lines @@
         # setUp.
         d = defer.succeed(None)
         def create_table(engine):
             engine.execute("CREATE TABLE tmp ( a integer )")
         d.addCallback( lambda r : self.pool.do_with_engine(create_table))
         def insert_into_table(engine):
             engine.execute("INSERT INTO tmp values ( 1 )")
         d.addCallback( lambda r : self.pool.do_with_engine(insert_into_table))
         return d
 
+
+class Stress(unittest.TestCase):
+
+    def setUp(self):
+        setup_engine = sa.create_engine('sqlite:///test.sqlite')
+        setup_engine.execute("pragma journal_mode = wal")
+        setup_engine.execute("CREATE TABLE test (a integer, b integer)")
+
+        self.engine = sa.create_engine('sqlite:///test.sqlite')
+        self.engine.optimal_thread_pool_size = 2
+        self.pool = pool.DBThreadPool(self.engine)
+
+    def tearDown(self):
+        self.pool.shutdown()
+        os.unlink("test.sqlite")
+
+    @defer.deferredGenerator
+    def test_inserts(self):
+        def write(conn):
+            trans = conn.begin()
+            conn.execute("INSERT INTO test VALUES (1, 1)")
+            time.sleep(31)
+            trans.commit()
+        d1 = self.pool.do(write)
+
+        def write2(conn):
+            trans = conn.begin()
+            conn.execute("INSERT INTO test VALUES (1, 1)")
+            trans.commit()
+        d2 = defer.Deferred()
+        d2.addCallback(lambda _ :
+            self.pool.do(write2))
+        reactor.callLater(0.1, d2.callback, None)
+
+        wfd = defer.waitForDeferred(
+            defer.DeferredList([ d1, d2 ]))
+        yield wfd
+        wfd.getResult()
+
+    # don't run this test, since it takes 30s
+    del test_inserts
+
+
 class Native(unittest.TestCase, db.RealDatabaseMixin):
 
     # similar tests, but using the BUILDBOT_TEST_DB_URL
 
     def setUp(self):
         d = self.setUpRealDatabase(want_pool=False)
         def make_pool(_):
             self.pool = pool.DBThreadPool(self.db_engine)
         d.addCallback(make_pool)
         return d
@@ skipping 21 matching lines @@
             t = conn.begin()
             native_tests.create(bind=conn)
             t.commit()
         d = self.pool.do(ddl)
         def access(conn):
             native_tests.insert(bind=conn).execute([ {'name':'foo'} ])
         d.addCallback(lambda _ :
             self.pool.do(access))
         return d