[Zope-Checkins] CVS: Zope/lib/python/Products/Transience/tests - testTimeoutRelated.py:1.11.2.1 testTransientObject.py:1.8.68.1 testTransientObjectContainer.py:1.14.2.1

Chris McDonough chrism at plope.com
Fri May 14 18:52:14 EDT 2004


Update of /cvs-repository/Zope/lib/python/Products/Transience/tests
In directory cvs.zope.org:/tmp/cvs-serv26009/tests

Modified Files:
      Tag: Zope-2_7-branch
	testTimeoutRelated.py testTransientObject.py 
	testTransientObjectContainer.py 
Log Message:
New "Transience" implementation.  This implementation offers no new features,
but is is vastly simpler, which makes it easier to maintain.  The older version
used all sorts of (questionable) tricks to attempt to avoid conflicts and to
improve performance, such as using Python Queue-module queues to store action 
lists, using an index to quickly look up which "bucket" a transient object
was stored within and several other persistent objects which attempted to keep
pointers into the data.  The older version also had a lot of "voodoo" code in
it which papered over problems that was apparenly caused by its complexity.
This code is now removed/replaced and the implementation is fairly straight-
forward.

The newer version is probably much slower (due to the lack of an index, it
needs to scan all "current" buckets to attempt to find a value), but it 
operates reliably under high load. 

This implementation removes backwards compatibility support for transient
object containers persisted via the Zope 2.5.X implementation.  It is possible
to use it against instances created in Zope 2.6.X and better, and it
is possible after using it against a database created under one of these
flavors to move back to an "older" Zope in this range, although it is likely
that data in the TOC will be silently lost when this is done.


=== Zope/lib/python/Products/Transience/tests/testTimeoutRelated.py 1.11 => 1.11.2.1 ===
--- Zope/lib/python/Products/Transience/tests/testTimeoutRelated.py:1.11	Tue Jun 17 21:01:11 2003
+++ Zope/lib/python/Products/Transience/tests/testTimeoutRelated.py	Fri May 14 18:52:13 2004
@@ -58,6 +58,7 @@
     def setUp(self):
         Products.Transience.Transience.time = fauxtime
         Products.Transience.TransientObject.time = fauxtime
+        Products.Transience.Transience.setStrict(1)
         self.app = makerequest.makerequest(_getApp())
         timeout = self.timeout = 1
         sm=TransientObjectContainer(
@@ -72,6 +73,7 @@
         del self.app
         Products.Transience.Transience.time = oldtime
         Products.Transience.TransientObject.time = oldtime
+        Products.Transience.Transience.setStrict(0)
 
 class TestLastAccessed(TestBase):
     def testLastAccessed(self):
@@ -92,7 +94,7 @@
         # to get to the next Windows time.time() tick.
         fauxtime.sleep(WRITEGRANULARITY + 0.06 * 60)
         sdo = self.app.sm.get('TempObject')
-        assert sdo.getLastAccessed() > la1, (sdo.getLastAccessed(), la1)
+        self.assert_(sdo.getLastAccessed() > la1)
 
 class TestNotifications(TestBase):
     def testAddNotification(self):
@@ -100,8 +102,8 @@
         sdo = self.app.sm.new_or_existing('TempObject')
         now = fauxtime.time()
         k = sdo.get('starttime')
-        assert type(k) == type(now)
-        assert k <= now
+        self.assertEqual(type(k), type(now))
+        self.assert_(k <= now)
 
     def testDelNotification(self):
         self.app.sm.setDelNotificationTarget(delNotificationTarget)
@@ -110,12 +112,11 @@
         fauxtime.sleep(timeout + (timeout * .75))
         sdo1 = self.app.sm.get('TempObject')
         # force the sdm to do housekeeping
-        self.app.sm._housekeep(self.app.sm._deindex_next() -
-                                   self.app.sm._period)
+        self.app.sm._gc()
         now = fauxtime.time()
         k = sdo.get('endtime')
-        assert (type(k) == type(now)), type(k)
-        assert k <= now, (k, now)
+        self.assertEqual(type(k), type(now))
+        self.assert_(k <= now)
 
 def addNotificationTarget(item, context):
     item['starttime'] = fauxtime.time()


=== Zope/lib/python/Products/Transience/tests/testTransientObject.py 1.8 => 1.8.68.1 ===
--- Zope/lib/python/Products/Transience/tests/testTransientObject.py:1.8	Wed Aug 14 18:25:14 2002
+++ Zope/lib/python/Products/Transience/tests/testTransientObject.py	Fri May 14 18:52:13 2004
@@ -25,6 +25,7 @@
     def setUp(self):
         Products.Transience.Transience.time = fauxtime
         Products.Transience.TransientObject.time = fauxtime
+        Products.Transience.Transience.setStrict(1)
         self.errmargin = .20
         self.timeout = 60
         self.t = TransientObjectContainer('sdc', timeout_mins=self.timeout/60)
@@ -32,55 +33,56 @@
     def tearDown(self):
         Products.Transience.Transience.time = oldtime
         Products.Transience.TransientObject.time = oldtime
+        Products.Transience.Transience.setStrict(0)
         self.t = None
         del self.t
 
     def test_id(self):
         t = self.t.new('xyzzy')
-        assert t.getId() != 'xyzzy'
-        assert t.getContainerKey() == 'xyzzy'
+        self.failIfEqual(t.getId(), 'xyzzy') # dont acquire
+        self.assertEqual(t.getContainerKey(), 'xyzzy')
 
     def test_validate(self):
         t = self.t.new('xyzzy')
-        assert t.isValid()
+        self.assert_(t.isValid())
         t.invalidate()
-        assert not t.isValid()
+        self.failIf(t.isValid())
 
     def test_getLastAccessed(self):
         t = self.t.new('xyzzy')
         ft = fauxtime.time()
-        assert t.getLastAccessed() <= ft
+        self.assert_(t.getLastAccessed() <= ft)
 
     def test_getCreated(self):
         t = self.t.new('xyzzy')
         ft = fauxtime.time()
-        assert t.getCreated() <= ft
+        self.assert_(t.getCreated() <= ft)
 
     def test_getLastModifiedUnset(self):
         t = self.t.new('xyzzy')
-        assert t.getLastModified() == None
+        self.assertEqual(t.getLastModified(), None)
 
     def test_getLastModifiedSet(self):
         t = self.t.new('xyzzy')
         t['a'] = 1
-        assert t.getLastModified() is not None
+        self.failIfEqual(t.getLastModified(), None)
 
     def testSetLastModified(self):
         t = self.t.new('xyzzy')
         ft = fauxtime.time()
         t.setLastModified()
-        assert t.getLastModified() is not None
+        self.failIfEqual(t.getLastModified(), None)
 
     def test_setLastAccessed(self):
         t = self.t.new('xyzzy')
         ft = fauxtime.time()
-        assert t.getLastAccessed() <= ft
+        self.assert_(t.getLastAccessed() <= ft)
         fauxtime.sleep(self.timeout)   # go to sleep past the granuarity
         ft2 = fauxtime.time()
         t.setLastAccessed()
         ft3 = fauxtime.time()
-        assert t.getLastAccessed() <= ft3
-        assert t.getLastAccessed() >= ft2
+        self.assert_(t.getLastAccessed() <= ft3)
+        self.assert_(t.getLastAccessed() >= ft2)
 
     def _genKeyError(self, t):
         return t.get('foobie')
@@ -91,27 +93,27 @@
     def test_dictionaryLike(self):
         t = self.t.new('keytest')
         t.update(data)
-        assert t.keys() == data.keys()
-        assert t.values() == data.values()
-        assert t.items() == data.items()
+        self.assertEqual(t.keys(), data.keys())
+        self.assertEqual(t.values(), data.values())
+        self.assertEqual(t.items(), data.items())
         for k in data.keys():
-            assert t.get(k) == data.get(k)
-        assert t.get('foobie') is None
+            self.assertEqual(t.get(k), data.get(k))
+        self.assertEqual(t.get('foobie'), None)
         self.assertRaises(AttributeError, self._genLenError, t)
-        assert t.get('foobie',None) is None
-        assert t.has_key('a')
-        assert not t.has_key('foobie')
+        self.assertEqual(t.get('foobie',None), None)
+        self.assert_(t.has_key('a'))
+        self.failIf(t.has_key('foobie'))
         t.clear()
-        assert not len(t.keys())
+        self.assertEqual(len(t.keys()), 0)
 
     def test_TTWDictionary(self):
         t = self.t.new('mouthfultest')
         t.set('foo', 'bar')
-        assert t['foo'] == 'bar'
-        assert t.get('foo') == 'bar'
+        self.assertEqual(t['foo'], 'bar')
+        self.assertEqual(t.get('foo'), 'bar')
         t.set('foobie', 'blech')
         t.delete('foobie')
-        assert t.get('foobie') is None
+        self.assertEqual(t.get('foobie'), None)
 
 
 def test_suite():


=== Zope/lib/python/Products/Transience/tests/testTransientObjectContainer.py 1.14 => 1.14.2.1 ===
--- Zope/lib/python/Products/Transience/tests/testTransientObjectContainer.py:1.14	Thu May 15 11:21:53 2003
+++ Zope/lib/python/Products/Transience/tests/testTransientObjectContainer.py	Fri May 14 18:52:13 2004
@@ -30,14 +30,17 @@
     def setUp(self):
         Products.Transience.Transience.time = fauxtime
         Products.Transience.TransientObject.time = fauxtime
+        Products.Transience.Transience.setStrict(1)
+                                          
         self.errmargin = .20
-        self.timeout = 60
+        self.timeout = 120
         self.t = TransientObjectContainer('sdc', timeout_mins=self.timeout/60)
 
     def tearDown(self):
         self.t = None
         Products.Transience.Transience.time = oldtime
         Products.Transience.TransientObject.time = oldtime
+        Products.Transience.Transience.setStrict(0)
 
 class TestTransientObjectContainer(TestBase):
     def testGetItemFails(self):
@@ -47,30 +50,30 @@
         return self.t[10]
 
     def testGetReturnsDefault(self):
-        assert self.t.get(10) == None
-        assert self.t.get(10, 'foo') == 'foo'
+        self.assertEqual(self.t.get(10), None)
+        self.assertEqual(self.t.get(10, 'foo'), 'foo')
 
     def testSetItemGetItemWorks(self):
         self.t[10] = 1
         a = self.t[10]
-        assert a == 1, `a`
+        self.assertEqual(a, 1)
 
     def testReplaceWorks(self):
         self.t[10] = 1
-        assert self.t[10] == 1
+        self.assertEqual(self.t[10], 1)
         self.t[10] = 2
-        assert self.t[10] == 2
+        self.assertEqual(self.t[10], 2)
 
     def testHasKeyWorks(self):
         self.t[10] = 1
-        assert self.t.has_key(10)
+        self.failUnless(self.t.has_key(10))
 
     def testValuesWorks(self):
         for x in range(10, 110):
             self.t[x] = x
         v = self.t.values()
         v.sort()
-        assert len(v) == 100
+        self.assertEqual(len(v), 100)
         i = 10
         for x in v:
             assert x == i
@@ -81,10 +84,10 @@
             self.t[x] = x
         v = self.t.keys()
         v.sort()
-        assert len(v) == 100
+        self.assertEqual(len(v), 100)
         i = 10
         for x in v:
-            assert x == i
+            self.assertEqual(x, i)
             i = i + 1
 
     def testItemsWorks(self):
@@ -92,11 +95,11 @@
             self.t[x] = x
         v = self.t.items()
         v.sort()
-        assert len(v) == 100
+        self.assertEquals(len(v), 100)
         i = 10
         for x in v:
-            assert x[0] == i
-            assert x[1] == i
+            self.assertEqual(x[0], i)
+            self.assertEqual(x[1], i)
             i = i + 1
 
     def testDeleteInvalidKeyRaisesKeyError(self):
@@ -105,63 +108,6 @@
     def _deletefail(self):
         del self.t[10]
 
-    def donttestDeleteNoChildrenWorks(self):
-        self.t[5] = 6
-        self.t[2] = 10
-        self.t[6] = 12
-        self.t[1] = 100
-        self.t[3] = 200
-        self.t[10] = 500
-        self.t[4] = 99
-        del self.t[4]
-        assert lsubtract(self.t.keys(), [1,2,3,5,6,10]) == [], `self.t.keys()`
-
-    def donttestDeleteOneChildWorks(self):
-        self.t[5] = 6
-        self.t[2] = 10
-        self.t[6] = 12
-        self.t[1] = 100
-        self.t[3] = 200
-        self.t[10] = 500
-        self.t[4] = 99
-        del self.t[3]
-        assert lsubtract(self.t.keys(), [1,2,4,5,6,10]) == [], `self.t.keys()`
-
-    def donttestDeleteTwoChildrenNoInorderSuccessorWorks(self):
-        self.t[5] = 6
-        self.t[2] = 10
-        self.t[6] = 12
-        self.t[1] = 100
-        self.t[3] = 200
-        self.t[10] = 500
-        self.t[4] = 99
-        del self.t[2]
-        assert lsubtract(self.t.keys(),[1,3,4,5,6,10])==[], `self.t.keys()`
-
-    def donttestDeleteTwoChildrenInorderSuccessorWorks(self):
-        self.t[5] = 6
-        self.t[2] = 10
-        self.t[6] = 12
-        self.t[1] = 100
-        self.t[3] = 200
-        self.t[10] = 500
-        self.t[4] = 99
-        self.t[2.5] = 150
-        del self.t[2]
-        assert lsubtract(self.t.keys(),[1,2.5,3,4,5,6,10])==[], `self.t.keys()`
-
-    def donttestDeleteRootWorks(self):
-        self.t[5] = 6
-        self.t[2] = 10
-        self.t[6] = 12
-        self.t[1] = 100
-        self.t[3] = 200
-        self.t[10] = 500
-        self.t[4] = 99
-        self.t[2.5] = 150
-        del self.t[5]
-        assert lsubtract(self.t.keys(),[1,2,2.5,3,4,6,10])==[], `self.t.keys()`
-
     def testRandomNonOverlappingInserts(self):
         added = {}
         r = range(10, 110)
@@ -172,7 +118,7 @@
                 added[k] = 1
         addl = added.keys()
         addl.sort()
-        assert lsubtract(self.t.keys(),addl)==[], `self.t.keys()`
+        self.assertEqual(lsubtract(self.t.keys(),addl), [])
 
     def testRandomOverlappingInserts(self):
         added = {}
@@ -183,7 +129,7 @@
             added[k] = 1
         addl = added.keys()
         addl.sort()
-        assert lsubtract(self.t.keys(), addl) ==[]
+        self.assertEqual(lsubtract(self.t.keys(), addl), [])
 
     def testRandomDeletes(self):
         r = range(10, 1010)
@@ -204,19 +150,28 @@
         for x in deleted:
             if self.t.has_key(x):
                 badones.append(x)
-        assert badones == [], (badones, added, deleted)
+        self.assertEqual(badones, [])
 
     def testTargetedDeletes(self):
         r = range(10, 1010)
+        seen = {}
         for x in r:
             k = random.choice(r)
+            vals = seen.setdefault(k, [])
+            vals.append(x)
             self.t[k] = x
+        couldntdelete = {}
+        weird = []
+        results = {}
         for x in r:
             try:
-                del self.t[x]
-            except KeyError:
-                pass
-        assert self.t.keys() == [], `self.t.keys()`
+                ts, item = self.t.__delitem__(x)
+                results[x] = ts, item
+            except KeyError, v:
+                if v.args[0] != x:
+                    weird.append(x)
+                couldntdelete[x] = v.args[0]
+        self.assertEqual(self.t.keys(), [])
 
     def testPathologicalRightBranching(self):
         r = range(10, 1010)
@@ -224,7 +179,7 @@
             self.t[x] = 1
         assert list(self.t.keys()) == r, (self.t.keys(), r)
         map(self.t.__delitem__, r)
-        assert list(self.t.keys()) == [], self.t.keys()
+        self.assertEqual(list(self.t.keys()), [])
 
     def testPathologicalLeftBranching(self):
         r = range(10, 1010)
@@ -232,11 +187,11 @@
         revr.reverse()
         for x in revr:
             self.t[x] = 1
-        assert list(self.t.keys()) == r, (self.t.keys(), r)
+        self.assertEqual(list(self.t.keys()), r)
         map(self.t.__delitem__, revr)
-        assert list(self.t.keys()) == [], self.t.keys()
+        self.assertEqual(list(self.t.keys()), [])
 
-    def donttestSuccessorChildParentRewriteExerciseCase(self):
+    def testSuccessorChildParentRewriteExerciseCase(self):
         add_order = [
             85, 73, 165, 273, 215, 142, 233, 67, 86, 166, 235, 225, 255,
             73, 175, 171, 285, 162, 108, 28, 283, 258, 232, 199, 260,
@@ -280,37 +235,7 @@
         for x in delete_order:
             try: del self.t[x]
             except KeyError:
-                if self.t.has_key(x): assert 1==2,"failed to delete %s" % x
-
-    def testChangingTimeoutWorks(self):
-        # 1 minute
-        for x in range(10, 110):
-            self.t[x] = x
-        fauxtime.sleep(self.timeout * (self.errmargin+1))
-        assert len(self.t.keys()) == 0, len(self.t.keys())
-
-        # 2 minutes
-        self.t._setTimeout(self.timeout/60*2)
-        self.t._reset()
-        for x in range(10, 110):
-            self.t[x] = x
-        fauxtime.sleep(self.timeout)
-        assert len(self.t.keys()) == 100, len(self.t.keys())
-        fauxtime.sleep(self.timeout * (self.errmargin+1))
-        assert len(self.t.keys()) == 0, len(self.t.keys())
-
-        # 3 minutes
-        self.t._setTimeout(self.timeout/60*3)
-        self.t._reset()
-        for x in range(10, 110):
-            self.t[x] = x
-        fauxtime.sleep(self.timeout)
-        assert len(self.t.keys()) == 100, len(self.t.keys())
-        fauxtime.sleep(self.timeout)
-        assert len(self.t.keys()) == 100, len(self.t.keys())
-        fauxtime.sleep(self.timeout * (self.errmargin+1))
-        assert len(self.t.keys()) == 0, len(self.t.keys())
-
+                self.failIf(self.t.has_key(x))
 
     def testItemsGetExpired(self):
         for x in range(10, 110):
@@ -319,10 +244,15 @@
         fauxtime.sleep(self.timeout * (self.errmargin+1))
         for x in range(110, 210):
             self.t[x] = x
-        assert len(self.t.keys()) == 100, len(self.t.keys())
+        self.assertEqual(len(self.t.keys()), 100)
+
+        # call _gc just to make sure __len__ gets changed after a gc
+        self.t._gc()
+        self.assertEqual(len(self.t), 100)
+
         # we should still have 100 - 199
         for x in range(110, 210):
-            assert self.t[x] == x
+            self.assertEqual(self.t[x], x)
         # but we shouldn't have 0 - 100
         for x in range(10, 110):
             try: self.t[x]
@@ -334,7 +264,7 @@
         for x in range(10, 110):
             self.t[x] = x
         fauxtime.sleep(self.timeout * (self.errmargin+1))
-        assert len(self.t.keys()) == 0, len(self.t.keys())
+        self.assertEqual(len(self.t.keys()), 0)
 
         # 2 minutes
         self.t._setTimeout(self.timeout/60*2)
@@ -342,9 +272,11 @@
         for x in range(10, 110):
             self.t[x] = x
         fauxtime.sleep(self.timeout)
-        assert len(self.t.keys()) == 100, len(self.t.keys())
+
+
+        self.assertEqual(len(self.t.keys()), 100)
         fauxtime.sleep(self.timeout * (self.errmargin+1))
-        assert len(self.t.keys()) == 0, len(self.t.keys())
+        self.assertEqual(len(self.t.keys()), 0)
 
         # 3 minutes
         self.t._setTimeout(self.timeout/60*3)
@@ -352,11 +284,11 @@
         for x in range(10, 110):
             self.t[x] = x
         fauxtime.sleep(self.timeout)
-        assert len(self.t.keys()) == 100, len(self.t.keys())
+        self.assertEqual(len(self.t.keys()), 100)
         fauxtime.sleep(self.timeout)
-        assert len(self.t.keys()) == 100, len(self.t.keys())
+        self.assertEqual(len(self.t.keys()), 100)
         fauxtime.sleep(self.timeout * (self.errmargin+1))
-        assert len(self.t.keys()) == 0, len(self.t.keys())
+        self.assertEqual(len(self.t.keys()), 0)
 
     def testGetDelaysTimeout(self):
         for x in range(10, 110):
@@ -367,9 +299,9 @@
         for x in range(10, 110):
             self.t.get(x)
         fauxtime.sleep(self.timeout/2)
-        assert len(self.t.keys()) == 100, len(self.t.keys())
+        self.assertEqual(len(self.t.keys()), 100)
         for x in range(10, 110):
-            assert self.t[x] == x
+            self.assertEqual(self.t[x], x)
 
     def testSetItemDelaysTimeout(self):
         for x in range(10, 110):
@@ -395,19 +327,25 @@
             added[k] = x
         self.assertEqual(len(self.t), len(added))
 
+        for k in added.keys():
+            del self.t[k]
+
+        self.assertEqual(len(self.t), 0)
+        
+
     def testResetWorks(self):
         self.t[10] = 1
         self.t._reset()
-        assert not self.t.get(10)
+        self.failIf(self.t.get(10))
 
     def testGetTimeoutMinutesWorks(self):
-        assert self.t.getTimeoutMinutes() == self.timeout / 60
+        self.assertEqual(self.t.getTimeoutMinutes(), self.timeout / 60)
         self.t._setTimeout(10)
-        assert self.t.getTimeoutMinutes() == 10
+        self.assertEqual(self.t.getTimeoutMinutes(), 10)
 
     def test_new(self):
         t = self.t.new('foobieblech')
-        assert issubclass(t.__class__, TransientObject)
+        self.failUnless(issubclass(t.__class__, TransientObject))
 
     def _dupNewItem(self):
         t = self.t.new('foobieblech')
@@ -420,18 +358,23 @@
         t = self.t.new('foobieblech')
         t['hello'] = "Here I am!"
         t2 = self.t.new_or_existing('foobieblech')
-        assert t2['hello'] == "Here I am!"
+        self.assertEqual(t2['hello'], "Here I am!")
 
     def test_getId(self):
-        assert self.t.getId() == 'sdc'
+        self.assertEqual(self.t.getId(), 'sdc')
 
     def testSubobjectLimitWorks(self):
         self.t = TransientObjectContainer('a', timeout_mins=self.timeout/60,
                                           limit=10)
         self.assertRaises(MaxTransientObjectsExceeded, self._maxOut)
 
-    def testUnlimitedSubobjectLimitWorks(self):
-        self._maxOut()
+    def testZeroTimeoutMeansPersistForever(self):
+        self.t._setTimeout(0)
+        self.t._reset()
+        for x in range(10, 110):
+            self.t[x] = x
+        fauxtime.sleep(180)
+        self.assertEqual(len(self.t.keys()), 100)
 
     def _maxOut(self):
         for x in range(11):
@@ -447,7 +390,6 @@
 
 def test_suite():
     testsuite = makeSuite(TestTransientObjectContainer, 'test')
-    #testsuite = makeSuite(TestBase, 'test')
     alltests = TestSuite((testsuite,))
     return alltests
 




More information about the Zope-Checkins mailing list