Coverage for 'UnboundedCache'.

Move docstrings for 'LRUCache' methods to base class abstract versions,
which gets them ~covered~ too.

2 files changed, 61 insertions, 5 deletions

diff --git a/repoze/lru/__init__.py b/repoze/lru/__init__.py
index 8db3087..30d1aa5 100644
--- a/repoze/lru/__init__.py
+++ b/repoze/lru/__init__.py
@@ -18,19 +18,19 @@ class Cache(object):
 
     @abstractmethod
     def clear(self):
-        pass
+        """Remove all entries from the cache"""
 
     @abstractmethod
     def get(self, key, default=None):
-        pass
+        """Return value for key. If not in cache, return default"""
 
     @abstractmethod
     def put(self, key, val):
-        pass
+        """Add key to the cache with value val"""
 
     @abstractmethod
     def invalidate(self, key):
-        pass
+        """Remove key from the cache"""
 
 
 class UnboundedCache(Cache):
@@ -48,7 +48,10 @@ class UnboundedCache(Cache):
         self._data.clear()
 
     def invalidate(self, key):
-        del self._data[key]
+        try:
+            del self._data[key]
+        except KeyError:
+            pass
 
     def put(self, key, val):
         self._data[key] = val
diff --git a/repoze/lru/tests.py b/repoze/lru/tests.py
index 1fe9c87..5cdb739 100644
--- a/repoze/lru/tests.py
+++ b/repoze/lru/tests.py
@@ -8,12 +8,65 @@ except NameError: # pragma: NO COVER  (Python3)
     pass
 
 
+class UnboundedCacheTests(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from repoze.lru import UnboundedCache
+        return UnboundedCache
+
+    def _makeOne(self):
+        return self._getTargetClass()()
+
+    def test_ctor(self):
+        cache = self._makeOne()
+        self.assertEqual(cache._data, {})
+
+    def test_get_miss_no_default(self):
+        cache = self._makeOne()
+        self.assertIsNone(cache.get('nonesuch'))
+
+    def test_get_miss_explicit_default(self):
+        cache = self._makeOne()
+        default = object()
+        self.assertIs(cache.get('nonesuch', default), default)
+
+    def test_get_hit(self):
+        cache = self._makeOne()
+        extant = cache._data['extant'] = object()
+        self.assertIs(cache.get('extant'), extant)
+
+    def test_clear(self):
+        cache = self._makeOne()
+        extant = cache._data['extant'] = object()
+        cache.clear()
+        self.assertIsNone(cache.get('extant'))
+
+    def test_invalidate_miss(self):
+        cache = self._makeOne()
+        cache.invalidate('nonesuch')  # does not raise
+
+    def test_invalidate_hit(self):
+        cache = self._makeOne()
+        extant = cache._data['extant'] = object()
+        cache.invalidate('extant')
+        self.assertIsNone(cache.get('extant'))
+
+    def test_put(self):
+        cache = self._makeOne()
+        extant = object()
+        cache.put('extant', extant)
+        self.assertIs(cache._data['extant'], extant)
+
+
 class LRUCacheTests(unittest.TestCase):
 
     def _getTargetClass(self):
         from repoze.lru import LRUCache
         return LRUCache
 
+    def _makeOne(self, size):
+        return self._getTargetClass()(size)
+
     def check_cache_is_consistent(self, cache):
         #Return if cache is consistent, else raise fail test case.
         # cache.hand/maxpos/size