Make cache region invalidation pluggable

Introduce class RegionInvalidationStrategy that performs region
invalidation. Add region_invalidator parameter
to CacheRegion.configure to pass custom invalidator object.

Fixes: #38
Change-Id: I62f5394e3916ed8debf9e23fcd18df4c4793f69c

1 files changed, 52 insertions, 0 deletions

diff --git a/tests/cache/test_region.py b/tests/cache/test_region.py
index b3a245a..b08b1ad 100644
--- a/tests/cache/test_region.py
+++ b/tests/cache/test_region.py
@@ -4,6 +4,7 @@ from dogpile.cache import exception
 from dogpile.cache import make_region, CacheRegion
 from dogpile.cache.proxy import ProxyBackend
 from dogpile.cache.region import _backend_loader
+from dogpile.cache.region import RegionInvalidationStrategy
 from . import eq_, is_, assert_raises_message, io, configparser
 import time
 import datetime
@@ -425,6 +426,57 @@ class ProxyRegionTest(RegionTest):
         return reg
 
 
+class CustomInvalidationStrategyTest(RegionTest):
+
+    """Try region tests with custom invalidation strategy.
+
+    This is exactly the same as the region test above, but it uses custom
+    invalidation strategy. The purpose of this is to make sure the tests
+    still run successfully even when there is a proxy.
+
+    """
+
+    class CustomInvalidationStrategy(RegionInvalidationStrategy):
+
+        def __init__(self):
+            self._soft_invalidated = None
+            self._hard_invalidated = None
+
+        def invalidate(self, hard=None):
+            if hard:
+                self._soft_invalidated = None
+                self._hard_invalidated = time.time()
+            else:
+                self._soft_invalidated = time.time()
+                self._hard_invalidated = None
+
+        def is_invalidated(self, timestamp):
+            return ((self._soft_invalidated and
+                     timestamp < self._soft_invalidated) or
+                    (self._hard_invalidated and
+                     timestamp < self._hard_invalidated))
+
+        def was_hard_invalidated(self):
+            return bool(self._hard_invalidated)
+
+        def is_hard_invalidated(self, timestamp):
+            return (self._hard_invalidated and
+                    timestamp < self._hard_invalidated)
+
+        def was_soft_invalidated(self):
+            return bool(self._soft_invalidated)
+
+        def is_soft_invalidated(self, timestamp):
+            return (self._soft_invalidated and
+                    timestamp < self._soft_invalidated)
+
+    def _region(self, init_args={}, config_args={}, backend="mock"):
+        reg = CacheRegion(**init_args)
+        invalidator = self.CustomInvalidationStrategy()
+        reg.configure(backend, region_invalidator=invalidator, **config_args)
+        return reg
+
+
 class ProxyBackendTest(TestCase):
 
     class GetCounterProxy(ProxyBackend):