Add unit tests for overridden getsizeof() method.

6 files changed, 113 insertions, 92 deletions

diff --git a/tests/__init__.py b/tests/__init__.py
index 401dd42..c3dde25 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -1,10 +1,13 @@
 class CacheTestMixin(object):
 
-    def cache(self, maxsize, missing=None, getsizeof=None):
-        raise NotImplementedError
+    Cache = None
 
-    def test_cache_defaults(self):
-        cache = self.cache(maxsize=1)
+#    def cache(self, maxsize, missing=None, getsizeof=None):
+#        c = self.Cache(maxsize, missing=missing, getsizeof=getsizeof)
+#        return c
+
+    def test_defaults(self):
+        cache = self.Cache(maxsize=1)
         self.assertEqual(0, len(cache))
         self.assertEqual(1, cache.maxsize)
         self.assertEqual(0, cache.currsize)
@@ -13,8 +16,8 @@ class CacheTestMixin(object):
         self.assertEqual(1, cache.getsizeof(0))
         self.assertTrue(repr(cache).startswith(cache.__class__.__name__))
 
-    def test_cache_insert(self):
-        cache = self.cache(maxsize=2)
+    def test_insert(self):
+        cache = self.Cache(maxsize=2)
 
         cache.update({1: 1, 2: 2})
         self.assertEqual(2, len(cache))
@@ -31,8 +34,8 @@ class CacheTestMixin(object):
         self.assertEqual(4, cache[4])
         self.assertTrue(1 in cache or 2 in cache or 3 in cache)
 
-    def test_cache_update(self):
-        cache = self.cache(maxsize=2)
+    def test_update(self):
+        cache = self.Cache(maxsize=2)
 
         cache.update({1: 1, 2: 2})
         self.assertEqual(2, len(cache))
@@ -49,8 +52,8 @@ class CacheTestMixin(object):
         self.assertEqual('a', cache[1])
         self.assertEqual('b', cache[2])
 
-    def test_cache_delete(self):
-        cache = self.cache(maxsize=2)
+    def test_delete(self):
+        cache = self.Cache(maxsize=2)
 
         cache.update({1: 1, 2: 2})
         self.assertEqual(2, len(cache))
@@ -73,8 +76,8 @@ class CacheTestMixin(object):
         self.assertNotIn(1, cache)
         self.assertNotIn(2, cache)
 
-    def test_cache_pop(self):
-        cache = self.cache(maxsize=2)
+    def test_pop(self):
+        cache = self.Cache(maxsize=2)
 
         cache.update({1: 1, 2: 2})
         self.assertEqual(2, cache.pop(2))
@@ -93,8 +96,8 @@ class CacheTestMixin(object):
         self.assertEqual(None, cache.pop(1, None))
         self.assertEqual(None, cache.pop(0, None))
 
-    def test_cache_popitem(self):
-        cache = self.cache(maxsize=2)
+    def test_popitem(self):
+        cache = self.Cache(maxsize=2)
 
         cache.update({1: 1, 2: 2})
         self.assertIn(cache.pop(1), {1: 1, 2: 2})
@@ -105,9 +108,9 @@ class CacheTestMixin(object):
         with self.assertRaises(KeyError):
             cache.popitem()
 
-    def test_cache_missing(self):
-        cache = self.cache(maxsize=2, missing=lambda x: x)
-
+    def _test_missing(self, cache):
+        self.assertEqual(0, cache.currsize)
+        self.assertEqual(2, cache.maxsize)
         self.assertEqual(0, len(cache))
         self.assertEqual(1, cache[1])
         self.assertEqual(2, cache[2])
@@ -157,8 +160,9 @@ class CacheTestMixin(object):
         self.assertTrue(1 in cache or 2 in cache)
         self.assertTrue(1 not in cache or 2 not in cache)
 
-        cache = self.cache(maxsize=2, missing=lambda x: x,
-                           getsizeof=lambda x: x)
+    def _test_missing_getsizeof(self, cache):
+        self.assertEqual(0, cache.currsize)
+        self.assertEqual(2, cache.maxsize)
         self.assertEqual(1, cache[1])
         self.assertIn(1, cache)
         self.assertEqual(2, cache[2])
@@ -169,10 +173,26 @@ class CacheTestMixin(object):
         self.assertIn(2, cache)
         self.assertNotIn(3, cache)
 
-    def test_cache_getsizeof(self):
-        cache = self.cache(maxsize=3, getsizeof=lambda x: x)
-        self.assertEqual(3, cache.maxsize)
+    def test_missing_param(self):
+        self._test_missing(self.Cache(maxsize=2, missing=lambda x: x))
+        self._test_missing_getsizeof(self.Cache(maxsize=2, missing=lambda x: x,
+                                                getsizeof=lambda x: x))
+
+    def test_missing_subclass(self):
+        class Cache(self.Cache):
+            def __missing__(self, key):
+                try:
+                    self[key] = key
+                except ValueError:
+                    pass
+                return key
+
+        self._test_missing(Cache(maxsize=2))
+        self._test_missing_getsizeof(Cache(maxsize=2, getsizeof=lambda x: x))
+
+    def _test_getsizeof(self, cache):
         self.assertEqual(0, cache.currsize)
+        self.assertEqual(3, cache.maxsize)
         self.assertEqual(1, cache.getsizeof(1))
         self.assertEqual(2, cache.getsizeof(2))
         self.assertEqual(3, cache.getsizeof(3))
@@ -214,10 +234,20 @@ class CacheTestMixin(object):
         self.assertEqual(3, cache.currsize)
         self.assertEqual(3, cache[3])
 
-    def test_cache_pickle(self):
+    def test_getsizeof_param(self):
+        self._test_getsizeof(self.Cache(maxsize=3, getsizeof=lambda x: x))
+
+    def test_getsizeof_subclass(self):
+        class Cache(self.Cache):
+            def getsizeof(self, value):
+                return value
+
+        self._test_getsizeof(Cache(maxsize=3))
+
+    def test_pickle(self):
         import pickle
 
-        source = self.cache(maxsize=2)
+        source = self.Cache(maxsize=2)
         source.update({1: 1, 2: 2})
 
         cache = pickle.loads(pickle.dumps(source))
@@ -239,13 +269,13 @@ class CacheTestMixin(object):
 
         self.assertEqual(cache, pickle.loads(pickle.dumps(cache)))
 
-    def test_cache_pickle_maxsize(self):
+    def test_pickle_maxsize(self):
         import pickle
         import sys
 
         # test empty cache, single element, large cache (recursion limit)
         for n in [0, 1, sys.getrecursionlimit() * 2]:
-            source = self.cache(maxsize=n)
+            source = self.Cache(maxsize=n)
             source.update((i, i) for i in range(n))
             cache = pickle.loads(pickle.dumps(source))
             self.assertEqual(n, len(cache))
diff --git a/tests/test_cache.py b/tests/test_cache.py
index 3b78515..ef87877 100644
--- a/tests/test_cache.py
+++ b/tests/test_cache.py
@@ -1,11 +1,10 @@
 import unittest
 
-from cachetools import Cache
+import cachetools
 
 from . import CacheTestMixin
 
 
 class CacheTest(unittest.TestCase, CacheTestMixin):
 
-    def cache(self, maxsize, missing=None, getsizeof=None):
-        return Cache(maxsize, missing=missing, getsizeof=getsizeof)
+    Cache = cachetools.Cache
diff --git a/tests/test_lfu.py b/tests/test_lfu.py
index fe0437e..6679a88 100644
--- a/tests/test_lfu.py
+++ b/tests/test_lfu.py
@@ -7,11 +7,10 @@ from . import CacheTestMixin
 
 class LFUCacheTest(unittest.TestCase, CacheTestMixin):
 
-    def cache(self, maxsize, missing=None, getsizeof=None):
-        return LFUCache(maxsize, missing=missing, getsizeof=getsizeof)
+    Cache = LFUCache
 
     def test_lfu(self):
-        cache = self.cache(maxsize=2)
+        cache = LFUCache(maxsize=2)
 
         cache[1] = 1
         cache[1]
@@ -29,7 +28,7 @@ class LFUCacheTest(unittest.TestCase, CacheTestMixin):
         self.assertEqual(cache[1], 1)
 
     def test_lfu_getsizeof(self):
-        cache = self.cache(maxsize=3, getsizeof=lambda x: x)
+        cache = LFUCache(maxsize=3, getsizeof=lambda x: x)
 
         cache[1] = 1
         cache[2] = 2
diff --git a/tests/test_lru.py b/tests/test_lru.py
index a94a517..fe97803 100644
--- a/tests/test_lru.py
+++ b/tests/test_lru.py
@@ -7,11 +7,10 @@ from . import CacheTestMixin
 
 class LRUCacheTest(unittest.TestCase, CacheTestMixin):
 
-    def cache(self, maxsize, missing=None, getsizeof=None):
-        return LRUCache(maxsize, missing=missing, getsizeof=getsizeof)
+    Cache = LRUCache
 
     def test_lru(self):
-        cache = self.cache(maxsize=2)
+        cache = LRUCache(maxsize=2)
 
         cache[1] = 1
         cache[2] = 2
@@ -36,7 +35,7 @@ class LRUCacheTest(unittest.TestCase, CacheTestMixin):
         self.assertNotIn(2, cache)
 
     def test_lru_getsizeof(self):
-        cache = self.cache(maxsize=3, getsizeof=lambda x: x)
+        cache = LRUCache(maxsize=3, getsizeof=lambda x: x)
 
         cache[1] = 1
         cache[2] = 2
diff --git a/tests/test_rr.py b/tests/test_rr.py
index 14a4b07..cff18bf 100644
--- a/tests/test_rr.py
+++ b/tests/test_rr.py
@@ -11,14 +11,18 @@ def choice(seq):
     return random.choice(seq)
 
 
+class RRTestCache(RRCache):
+    def __init__(self, maxsize, choice=choice, missing=None, getsizeof=None):
+        RRCache.__init__(self, maxsize, choice=choice,
+                         missing=missing, getsizeof=getsizeof)
+
+
 class RRCacheTest(unittest.TestCase, CacheTestMixin):
 
-    def cache(self, maxsize, choice=choice, missing=None, getsizeof=None):
-        return RRCache(maxsize, choice=choice, missing=missing,
-                       getsizeof=getsizeof)
+    Cache = RRTestCache
 
-    def test_choice(self):
-        cache = self.cache(maxsize=2, choice=min)
+    def test_rr_choice(self):
+        cache = RRCache(maxsize=2, choice=min)
         self.assertEqual(min, cache.choice)
 
         cache[1] = 1
diff --git a/tests/test_ttl.py b/tests/test_ttl.py
index 0927f5f..e8a086c 100644
--- a/tests/test_ttl.py
+++ b/tests/test_ttl.py
@@ -19,42 +19,18 @@ class Timer:
         self.time += 1
 
 
-class TTLCacheTest(unittest.TestCase, CacheTestMixin):
-
-    def cache(self, maxsize, ttl=0, missing=None, getsizeof=None):
-        return TTLCache(maxsize, ttl, timer=Timer(), missing=missing,
-                        getsizeof=getsizeof)
+class TTLTestCache(TTLCache):
+    def __init__(self, maxsize, ttl=0, missing=None, getsizeof=None):
+        TTLCache.__init__(self, maxsize, ttl=ttl, timer=Timer(),
+                          missing=missing, getsizeof=getsizeof)
 
-    def test_lru(self):
-        cache = self.cache(maxsize=2)
-
-        cache[1] = 1
-        cache[2] = 2
-        cache[3] = 3
 
-        self.assertEqual(len(cache), 2)
-        self.assertNotIn(1, cache)
-        self.assertEqual(cache[2], 2)
-        self.assertEqual(cache[3], 3)
-
-        cache[2]
-        cache[4] = 4
-        self.assertEqual(len(cache), 2)
-        self.assertNotIn(1, cache)
-        self.assertEqual(cache[2], 2)
-        self.assertNotIn(3, cache)
-        self.assertEqual(cache[4], 4)
+class TTLCacheTest(unittest.TestCase, CacheTestMixin):
 
-        cache[5] = 5
-        self.assertEqual(len(cache), 2)
-        self.assertNotIn(1, cache)
-        self.assertNotIn(2, cache)
-        self.assertNotIn(3, cache)
-        self.assertEqual(cache[4], 4)
-        self.assertEqual(cache[5], 5)
+    Cache = TTLTestCache
 
     def test_ttl(self):
-        cache = self.cache(maxsize=2, ttl=1)
+        cache = TTLCache(maxsize=2, ttl=1, timer=Timer())
         self.assertEqual(0, cache.timer())
         self.assertEqual(1, cache.ttl)
 
@@ -108,8 +84,36 @@ class TTLCacheTest(unittest.TestCase, CacheTestMixin):
         with self.assertRaises(KeyError):
             del cache[3]
 
-    def test_expire(self):
-        cache = self.cache(maxsize=3, ttl=2)
+    def test_ttl_lru(self):
+        cache = TTLCache(maxsize=2, ttl=0, timer=Timer())
+
+        cache[1] = 1
+        cache[2] = 2
+        cache[3] = 3
+
+        self.assertEqual(len(cache), 2)
+        self.assertNotIn(1, cache)
+        self.assertEqual(cache[2], 2)
+        self.assertEqual(cache[3], 3)
+
+        cache[2]
+        cache[4] = 4
+        self.assertEqual(len(cache), 2)
+        self.assertNotIn(1, cache)
+        self.assertEqual(cache[2], 2)
+        self.assertNotIn(3, cache)
+        self.assertEqual(cache[4], 4)
+
+        cache[5] = 5
+        self.assertEqual(len(cache), 2)
+        self.assertNotIn(1, cache)
+        self.assertNotIn(2, cache)
+        self.assertNotIn(3, cache)
+        self.assertEqual(cache[4], 4)
+        self.assertEqual(cache[5], 5)
+
+    def test_ttl_expire(self):
+        cache = TTLCache(maxsize=3, ttl=2, timer=Timer())
         with cache.timer as time:
             self.assertEqual(time, cache.timer())
         self.assertEqual(2, cache.ttl)
@@ -155,7 +159,7 @@ class TTLCacheTest(unittest.TestCase, CacheTestMixin):
         self.assertNotIn(2, cache)
         self.assertNotIn(3, cache)
 
-    def test_atomic(self):
+    def test_ttl_atomic(self):
         cache = TTLCache(maxsize=1, ttl=1, timer=Timer(auto=True))
         cache[1] = 1
         self.assertEqual(1, cache[1])
@@ -169,22 +173,8 @@ class TTLCacheTest(unittest.TestCase, CacheTestMixin):
         cache.clear()
         self.assertEqual(0, len(cache))
 
-    def test_missing(self):
-        class DefaultTTLCache(TTLCache):
-            def __missing__(self, key):
-                self[key] = key
-                return key
-
-        cache = DefaultTTLCache(maxsize=1, ttl=1, timer=Timer())
-        self.assertEqual(1, cache[1])
-        self.assertIn(1, cache)
-        self.assertNotIn(2, cache)
-        self.assertEqual(2, cache[2])
-        self.assertNotIn(1, cache)
-        self.assertIn(2, cache)
-
-    def test_tuple_key(self):
-        cache = self.cache(maxsize=1, ttl=0)
+    def test_ttl_tuple_key(self):
+        cache = TTLCache(maxsize=1, ttl=0, timer=Timer())
         self.assertEqual(0, cache.ttl)
 
         cache[(1, 2, 3)] = 42