Improved unit tests, found and fixed comparison bug.

Author: Cito

DBUtils/PooledDB.py

@@ -465,7 +465,7 @@ def __lt__(self, other):
 
     def __le__(self, other):
         if self.con._transaction == other.con._transaction:
-            return self.shared == other.shared
+            return self.shared <= other.shared
         else:
             return not self.con._transaction
 

DBUtils/Tests/TestPersistentDB.py

@@ -43,7 +43,7 @@ def test1_NoThreadsafety(self):
         for dbapi.threadsafety in (None, 0):
             self.assertRaises(NotSupportedError, PersistentDB, dbapi)
 
-    def test2_PersistentDBClose(self):
+    def test2_Close(self):
         for closeable in (False, True):
             persist = PersistentDB(dbapi, closeable=closeable)
             db = persist.connection()
@@ -57,7 +57,7 @@ def test2_PersistentDBClose(self):
             db._close()
             self.assert_(not db._con.valid)
 
-    def test3_PersistentDBConnection(self):
+    def test3_Connection(self):
         persist = PersistentDB(dbapi)
         db = persist.connection()
         db_con = db._con
@@ -71,7 +71,7 @@ def test3_PersistentDBConnection(self):
         db2.close()
         db.close()
 
-    def test4_PersistentDBThreads(self):
+    def test4_Threads(self):
         numThreads = 3
         persist = PersistentDB(dbapi, closeable=True)
         from Queue import Queue, Empty
@@ -181,7 +181,7 @@ def runQueries(i):
             except TypeError:
                 queryQueue[i].put(None, 1)
 
-    def test5_PersistentDBMaxUsage(self):
+    def test5_MaxUsage(self):
         persist = PersistentDB(dbapi, 20)
         db = persist.connection()
         self.assertEqual(db._maxusage, 20)
@@ -197,7 +197,7 @@ def test5_PersistentDBMaxUsage(self):
             self.assertEqual(db._con.num_uses, j)
             self.assertEqual(db._con.num_queries, j)
 
-    def test6_PersistentDBSetSession(self):
+    def test6_SetSession(self):
         persist = PersistentDB(dbapi, 3, ('set datestyle',))
         db = persist.connection()
         self.assertEqual(db._maxusage, 3)
@@ -215,7 +215,7 @@ def test6_PersistentDBSetSession(self):
             cursor.close()
         self.assertEqual(db._con.session, ['datestyle'])
 
-    def test7_PersistentDBThreadLocal(self):
+    def test7_ThreadLocal(self):
         persist = PersistentDB(dbapi)
         self.assert_(isinstance(persist.thread, ThreadingLocal.local))
         class threadlocal:

DBUtils/Tests/TestPersistentPg.py

@@ -34,7 +34,7 @@ def test0_CheckVersion(self):
         self.assertEqual(PersistentPgVersion, __version__)
         self.assertEqual(PersistentPg.version, __version__)
 
-    def test1_PersistentPgClose(self):
+    def test1_Close(self):
         for closeable in (False, True):
             persist = PersistentPg(closeable=closeable)
             db = persist.connection()
@@ -50,7 +50,7 @@ def test1_PersistentPgClose(self):
             db._close()
             self.assert_(not db._con.db or not db._con.valid)
 
-    def test2_PersistentPgThreads(self):
+    def test2_Threads(self):
         numThreads = 3
         persist = PersistentPg()
         from Queue import Queue, Empty
@@ -155,7 +155,7 @@ def runQueries(i):
             except TypeError:
                 queryQueue[i].put(None, 1)
 
-    def test3_PersistentPgMaxUsage(self):
+    def test3_MaxUsage(self):
         persist = PersistentPg(20)
         db = persist.connection()
         self.assertEqual(db._maxusage, 20)
@@ -167,7 +167,7 @@ def test3_PersistentPgMaxUsage(self):
             self.assertEqual(db._usage, j)
             self.assertEqual(db.num_queries, j)
 
-    def test4_PersistentPgSetSession(self):
+    def test4_SetSession(self):
         persist = PersistentPg(3, ('set datestyle',))
         db = persist.connection()
         self.assertEqual(db._maxusage, 3)
@@ -179,7 +179,7 @@ def test4_PersistentPgSetSession(self):
             db.query('select test')
         self.assertEqual(db.db.session, ['datestyle'])
 
-    def test5_PersistentPgFailedTransaction(self):
+    def test5_FailedTransaction(self):
         persist = PersistentPg()
         db = persist.connection()
         db._con.close()

DBUtils/Tests/TestPooledDB.py

@@ -22,7 +22,7 @@
 sys.path.insert(1, '../..')
 # The TestSteadyDB module serves as a mock object for the DB-API 2 module:
 from DBUtils.Tests import TestSteadyDB as dbapi
-from DBUtils.PooledDB import PooledDB, TooManyConnections
+from DBUtils.PooledDB import PooledDB, TooManyConnections, SharedDBConnection
 
 
 class TestPooledDB(unittest.TestCase):
@@ -393,7 +393,7 @@ def test06_ShareableConnection(self):
             else:
                 self.assertEqual(len(pool._idle_cache), 3)
 
-    def test07_MinMaxCached(self):
+    def test08_MinMaxCached(self):
         for threadsafety in (1, 2):
             dbapi.threadsafety = threadsafety
             shareable = threadsafety > 1
@@ -507,7 +507,26 @@ def test08_MaxShared(self):
             if shareable:
                 self.assertEqual(len(pool._shared_cache), 7)
 
-    def test09_EquallyShared(self):
+    def test09_SortShared(self):
+        dbapi.threadsafety = 2
+        pool = PooledDB(dbapi, 0, 4, 4)
+        cache = []
+        for i in range(6):
+            db = pool.connection()
+            db.cursor().execute('select test')
+            cache.append(db)
+        for i, db in enumerate(cache):
+            self.assertEqual(db._shared_con.shared, 2 <= i < 4 and 1 or 2)
+        cache[2].begin()
+        cache[3].begin()
+        db = pool.connection()
+        self.assert_(db._con is cache[0]._con)
+        db.close()
+        cache[3].rollback()
+        db = pool.connection()
+        self.assert_(db._con is cache[3]._con)
+
+    def test10_EquallyShared(self):
         for threadsafety in (1, 2):
             dbapi.threadsafety = threadsafety
             shareable = threadsafety > 1
@@ -542,7 +561,7 @@ def test09_EquallyShared(self):
             if shareable:
                 self.assertEqual(len(pool._shared_cache), 0)
 
-    def test10_SortShared(self):
+    def test11_ManyShared(self):
         for threadsafety in (1, 2):
             dbapi.threadsafety = threadsafety
             shareable = threadsafety > 1
@@ -593,7 +612,7 @@ def test10_SortShared(self):
             else:
                 self.assertEqual(len(pool._idle_cache), 35)
 
-    def test11_Rollback(self):
+    def test12_Rollback(self):
         for threadsafety in (1, 2):
             dbapi.threadsafety = threadsafety
             pool = PooledDB(dbapi, 0, 1)
@@ -625,7 +644,7 @@ def test11_Rollback(self):
                 'doit1', 'commit', 'dont1', 'rollback',
                 'doit2', 'commit', 'rollback'])
 
-    def test12_MaxConnections(self):
+    def test13_MaxConnections(self):
         for threadsafety in (1, 2):
             dbapi.threadsafety = threadsafety
             shareable = threadsafety > 1
@@ -827,7 +846,7 @@ def connection():
             self.assertEqual(session, ['rollback',
                 'rollback', 'thread', 'rollback'])
 
-    def test13_MaxUsage(self):
+    def test14_MaxUsage(self):
         for threadsafety in (1, 2):
             dbapi.threadsafety = threadsafety
             for maxusage in (0, 3, 7):
@@ -862,7 +881,7 @@ def test13_MaxUsage(self):
                 self.assertEqual(db._con._con.num_uses, j + 1)
                 self.assertEqual(db._con._con.num_queries, j)
 
-    def test14_SetSession(self):
+    def test15_SetSession(self):
         for threadsafety in (1, 2):
             dbapi.threadsafety = threadsafety
             setsession = ('set time zone', 'set datestyle')
@@ -890,7 +909,7 @@ def test14_SetSession(self):
             self.assertEqual(db._con._con.session,
                 ['time zone', 'datestyle', 'test2'])
 
-    def test15_OneThreadTwoConnections(self):
+    def test16_OneThreadTwoConnections(self):
         for threadsafety in (1, 2):
             dbapi.threadsafety = threadsafety
             shareable = threadsafety > 1
@@ -947,7 +966,7 @@ def test15_OneThreadTwoConnections(self):
             self.assertNotEqual(db1, db2)
             self.assertNotEqual(db1._con, db2._con)
 
-    def test16_ThreeThreadsTwoConnections(self):
+    def test17_ThreeThreadsTwoConnections(self):
         for threadsafety in (1, 2):
             dbapi.threadsafety = threadsafety
             pool = PooledDB(dbapi, 2, 2, 0, 2, True)
@@ -1004,7 +1023,7 @@ def connection():
             self.assertNotEqual(db1._con, db2._con)
             self.assertEqual(db1._con, db1_con)
 
-    def test17_PingCheck(self):
+    def test18_PingCheck(self):
         Connection = dbapi.Connection
         Connection.has_ping = True
         Connection.num_pings = 0
@@ -1072,7 +1091,7 @@ def test17_PingCheck(self):
         Connection.has_ping = False
         Connection.num_pings = 0
 
-    def test18_FailedTransaction(self):
+    def test19_FailedTransaction(self):
         dbapi.threadsafety = 2
         pool = PooledDB(dbapi, 0, 1, 1)
         db = pool.connection()
@@ -1101,15 +1120,35 @@ def test18_FailedTransaction(self):
         db._con._con.close()
         cursor.execute('select test')
 
-    def test19_AllSharedInTransaction(self):
+    def test20_SharedInTransaction(self):
         dbapi.threadsafety = 2
         pool = PooledDB(dbapi, 0, 1, 1)
         db = pool.connection()
         db.begin()
-        pool.connection(0)
+        pool.connection(False)
+        self.assertRaises(TooManyConnections, pool.connection)
+        pool = PooledDB(dbapi, 0, 2, 2)
+        db1 = pool.connection()
+        db2 = pool.connection()
+        self.assert_(db2._con is not db1._con)
+        db2.close()
+        db2 = pool.connection()
+        self.assert_(db2._con is not db1._con)
+        db = pool.connection()
+        self.assert_(db._con is db1._con)
+        db.close()
+        db1.begin()
+        db = pool.connection()
+        self.assert_(db._con is db2._con)
+        db.close()
+        db2.begin()
+        pool.connection(False)
         self.assertRaises(TooManyConnections, pool.connection)
+        db1.rollback()
+        db = pool.connection()
+        self.assert_(db._con is db1._con)
 
-    def test20_ResetTransaction(self):
+    def test21_ResetTransaction(self):
         pool = PooledDB(dbapi, 1, 1, 0)
         db = pool.connection()
         db.begin()
@@ -1132,5 +1171,52 @@ def test20_ResetTransaction(self):
         self.assertEqual(con._con.session, ['rollback'])
 
 
+class TestSharedDBConnection(unittest.TestCase):
+
+    def test01_CreateConnection(self):
+        db_con = dbapi.connect()
+        con = SharedDBConnection(db_con)
+        self.assertEqual(con.con, db_con)
+        self.assertEqual(con.shared, 1)
+
+    def test01_ShareAndUnshare(self):
+        con = SharedDBConnection(dbapi.connect())
+        self.assertEqual(con.shared, 1)
+        con.share()
+        self.assertEqual(con.shared, 2)
+        con.share()
+        self.assertEqual(con.shared, 3)
+        con.unshare()
+        self.assertEqual(con.shared, 2)
+        con.unshare()
+        self.assertEqual(con.shared, 1)
+
+    def test02_Comparison(self):
+        con1 = SharedDBConnection(dbapi.connect())
+        con1.con._transaction = False
+        con2 = SharedDBConnection(dbapi.connect())
+        con2.con._transaction = False
+        self.assert_(con1 == con2)
+        self.assert_(con1 <= con2)
+        self.assert_(con1 >= con2)
+        self.assert_(not con1 != con2)
+        self.assert_(not con1 < con2)
+        self.assert_(not con1 > con2)
+        con2.share()
+        self.assert_(not con1 == con2)
+        self.assert_(con1 <= con2)
+        self.assert_(not con1 >= con2)
+        self.assert_(con1 != con2)
+        self.assert_(con1 < con2)
+        self.assert_(not con1 > con2)
+        con1.con._transaction = True
+        self.assert_(not con1 == con2)
+        self.assert_(not con1 <= con2)
+        self.assert_(con1 >= con2)
+        self.assert_(con1 != con2)
+        self.assert_(not con1 < con2)
+        self.assert_(con1 > con2)
+
+
 if __name__ == '__main__':
     unittest.main()