def testDeleteExpiredOnGetItem(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict[1] = SomeObject('id1')
timedDict._now = lambda: time() + TWO_HOURS
self.assertRaises(KeyError, timedDict.__getitem__, 1)
self.assertEqual([], timedDict._expirationOrder)
def testPeek(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict[1] = "Now you see me, now you don't."
timedDict._now = lambda: time() + TWO_HOURS
self.assertEqual("Now you see me, now you don't.", timedDict.peek(1))
self.assertRaises(KeyError, timedDict.__getitem__, 1)
def testPurgeOnSetItem(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict[1] = SomeObject('id1')
timedDict._now = lambda: time() + TWO_HOURS
timedDict[2] = SomeObject('id2')
self.assertEqual([2], timedDict._expirationOrder)
def __init__(self, timeout, name=None, secure=False, httpOnly=False):
self._timeout = timeout
self._store = TimedDictionary(self._timeout)
self._name = '{0}{1}'.format('' if name is None else '%s-' % name,
uuid4())
self._secure = secure
self._httpOnly = httpOnly
def testTouch(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict[1] = SomeObject('id1')
timedDict[2] = SomeObject('id2')
self.assertEqual([1, 2], timedDict._expirationOrder)
timedDict.touch(1)
self.assertEqual([2, 1], timedDict._expirationOrder)
def testBasicDeletion(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict['key'] = 'five'
try:
del timedDict['key']
except:
self.fail("This shouldn't happen.")
self.assertRaises(KeyError, timedDict.__delitem__, 'idontexist')
def __init__(self,
cacheTimeout=1 * 60 * 60,
returnCachedValueInCaseOfException=False,
backoffTimeout=None,
**kwargs):
Transparent.__init__(self, **kwargs)
self._cache = TimedDictionary(timeout=cacheTimeout)
self._returnCachedValueInCaseOfException = returnCachedValueInCaseOfException
self._backoffTimeout = backoffTimeout
self._backoffStarted = None
def testSize(self):
timedDict = TimedDictionary(TWO_HOURS)
self.assertEqual(0, timedDict.size())
timedDict['key'] = 'five'
self.assertEqual(1, timedDict.size())
timedDict['key'] = 'six'
self.assertEqual(1, timedDict.size())
timedDict['key2'] = 'six'
self.assertEqual(2, timedDict.size())
timedDict._now = lambda: time() + TWO_HOURS
self.assertEqual(0, timedDict.size())
def testLruMaxSize(self):
timedDict = TimedDictionary(TWO_HOURS, lruMaxSize=2)
self.assertEqual(0, timedDict.size())
timedDict['key'] = 'five'
self.assertEqual(1, timedDict.size())
timedDict['key1'] = 'six'
self.assertEqual(2, timedDict.size())
self.assertEqual('five', timedDict['key'])
timedDict['key2'] = 'seven'
self.assertEqual(2, timedDict.size())
self.assertEqual(set(['key', 'key2']), set(timedDict.keys()))
def testBasicContains(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict[5] = 'five'
timedDict['six'] = 6
self.assertTrue(5 in timedDict)
self.assertTrue('six' in timedDict)
self.assertFalse(42 in timedDict)
self.assertFalse(None in timedDict)
self.assertTrue(5 in timedDict)
self.assertTrue('six' in timedDict)
self.assertFalse(42 in timedDict)
self.assertFalse(None in timedDict)
def testPop(self):
timedDict = TimedDictionary(TWO_HOURS)
setTime = time()
timedDict[1] = "Now you see me, now you don't."
self.assertEqual("Now you see me, now you don't.", timedDict.pop(1))
self.assertRaises(KeyError, lambda: timedDict.pop(1))
self.assertEqual("default", timedDict.pop(1, 'default'))
self.assertEqual(None, timedDict.pop(1, None))
self.assertEqual("default", timedDict.pop(1, default='default'))
self.assertEqual(None, timedDict.pop(1, default=None))
timedDict[1] = "Now you see me, now you don't."
setTime = time()
timedDict._now = lambda: setTime + TWO_HOURS + 0.000001
self.assertRaises(KeyError, lambda: timedDict.pop(1))
def testPurge(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict[1] = SomeObject('id1')
timedDict[2] = SomeObject('id2')
timedDict._now = lambda: time() + ONE_HOUR
self.assertEqual([1, 2], timedDict._expirationOrder)
timedDict[3] = SomeObject('id3')
timedDict.touch(2)
timedDict._now = lambda: time() + TWO_HOURS
timedDict.purge()
self.assertEqual([3, 2], timedDict._expirationOrder)
timedDict._now = lambda: time() + TWO_HOURS + TWO_HOURS
timedDict.purge()
self.assertEqual([], timedDict._expirationOrder)
def testExpirationOrderIsKeptInternally(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict[3] = SomeObject(1)
timedDict[1] = SomeObject(10)
timedDict[2] = SomeObject(20)
self.assertEqual([3, 1, 2], timedDict._expirationOrder)
timedDict[1] = SomeObject(23)
self.assertEqual([3, 2, 1], timedDict._expirationOrder)
timedDict[0] = SomeObject(23.01)
self.assertEqual([3, 2, 1, 0], timedDict._expirationOrder)
del timedDict[2]
self.assertEqual([3, 1, 0], timedDict._expirationOrder)
def testExpiredLeastRecentlyUsedGracefullyDealtWith(self):
timedDict = TimedDictionary(TWO_HOURS, lruMaxSize=2)
timedDict['key1'] = 'five'
timedDict['key2'] = 'six'
timedDict['key3'] = 'seven'
self.assertEqual(set(['key2', 'key3']), set(timedDict.keys()),
set(timedDict.keys()))
self.assertEqual(3, len(timedDict._times))
self.assertEqual(3, len(timedDict._expirationOrder))
timedDict.purge()
self.assertEqual(2, len(timedDict._times))
self.assertEqual(2, len(timedDict._expirationOrder))
timedDict._now = lambda: time() + TWO_HOURS
timedDict.purge()
self.assertEqual([], list(timedDict.keys()))
self.assertEqual(0, len(timedDict._times))
self.assertEqual(0, len(timedDict._expirationOrder))
def testExpiredOnInShouldReturnDefaultOnGetWithoutAnException(self):
timedDict = TimedDictionary(TWO_HOURS)
setTime = time()
timedDict._now = lambda: setTime
timedDict[1] = SomeObject('id1')
timedDict._now = lambda: setTime + TWO_HOURS
try:
1 in timedDict
except KeyError:
self.fail("Key shouldn't have expired yet.")
except:
self.fail("This should not happen.")
timedDict._now = lambda: setTime + TWO_HOURS + 0.000001
self.assertEqual(None, timedDict.get(1))
self.assertEqual('a default', timedDict.get(1, 'a default'))
self.assertEqual([], timedDict._expirationOrder)
def testBasicGetAndPut(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict['key'] = 'value'
self.assertEqual('value', timedDict['key'])
timedDict['key'] = 'otherValue'
self.assertEqual('otherValue', timedDict['key'])
timedDict['key'] = 5
self.assertEqual(5, timedDict['key'])
timedDict['key'] = 5.0
self.assertEqual(5.0, timedDict['key'])
timedDict['key'] = ['someMutable', 5]
self.assertEqual(['someMutable', 5], timedDict['key'])
self.assertEqual(['someMutable', 5], timedDict.get('key'))
self.assertRaises(TypeError, timedDict.__setitem__, [], 'value')
self.assertRaises(KeyError, timedDict.__getitem__, 'iamnothere')
self.assertEqual(None, timedDict.get('iamnothere'))
self.assertEqual('MARK', timedDict.get('iamnothere', 'MARK'))
def testClear(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict['key'] = 'five'
timedDict.clear()
self.assertRaises(KeyError, lambda: timedDict["key"])
def testGetTime(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict[1] = SomeObject('id1')
with stderr_replaced():
self.assertTrue(time() - timedDict.getTime(1) < 2.0)
def testUpdateTimeout(self):
timedDict = TimedDictionary(TWO_HOURS)
timedDict['key'] = 'five'
timedDict._now = lambda: time() + TWO_HOURS
timedDict.setTimeout(TWO_HOURS + 1)
self.assertEqual("five", timedDict["key"])
def CookieMemoryStore(timeout, *args, **kwargs):
return CookieStore(
TimedDictionary(timeout),
timeout,
*args, **kwargs)
