summaryrefslogtreecommitdiff
path: root/tests/_fixtures.py
diff options
context:
space:
mode:
Diffstat (limited to 'tests/_fixtures.py')
-rw-r--r--tests/_fixtures.py140
1 files changed, 121 insertions, 19 deletions
diff --git a/tests/_fixtures.py b/tests/_fixtures.py
index fa9ed5b..2e2e4bf 100644
--- a/tests/_fixtures.py
+++ b/tests/_fixtures.py
@@ -1,64 +1,166 @@
from dogpile.cache.api import CacheBackend, CachedValue, NO_VALUE
-from dogpile.cache import register_backend, CacheRegion
+from dogpile.cache import register_backend, CacheRegion, util
+from dogpile.cache.region import _backend_loader
from tests import eq_, assert_raises_message
import itertools
import time
from nose import SkipTest
-
+from threading import Thread, Lock
from unittest import TestCase
-class _GenericBackendTest(TestCase):
+class _GenericBackendFixture(object):
@classmethod
def setup_class(cls):
try:
- cls._region()
+ backend_cls = _backend_loader.load(cls.backend)
+ backend_cls(cls.config_args.get('arguments', {}))
except ImportError:
raise SkipTest("Backend %s not installed" % cls.backend)
- backend = None
region_args = {}
config_args = {}
- @classmethod
- def _region(cls, region_args={}, config_args={}):
- _region_args = {}
- _region_args = cls.region_args.copy()
+ _region_inst = None
+ _backend_inst = None
+
+ def _region(self, region_args={}, config_args={}):
+ _region_args = self.region_args.copy()
_region_args.update(**region_args)
- reg = CacheRegion(**_region_args)
- _config_args = cls.config_args.copy()
+ _config_args = self.config_args.copy()
_config_args.update(config_args)
- reg.configure(cls.backend, **_config_args)
+
+ self._region_inst = reg = CacheRegion(**_region_args)
+ reg.configure(self.backend, **_config_args)
return reg
- def test_set_get_value(self):
+ def _backend(self):
+ backend_cls = _backend_loader.load(self.backend)
+ _config_args = self.config_args.copy()
+ self._backend_inst = backend_cls(_config_args.get('arguments', {}))
+ return self._backend_inst
+
+ def tearDown(self):
+ if self._region_inst:
+ self._region_inst.delete("some key")
+ elif self._backend_inst:
+ self._backend_inst.delete("some_key")
+
+class _GenericBackendTest(_GenericBackendFixture, TestCase):
+ def test_backend_get_nothing(self):
+ backend = self._backend()
+ eq_(backend.get("some_key"), NO_VALUE)
+
+ def test_backend_delete_nothing(self):
+ backend = self._backend()
+ backend.delete("some_key")
+
+ def test_backend_set_get_value(self):
+ backend = self._backend()
+ backend.set("some_key", "some value")
+ eq_(backend.get("some_key"), "some value")
+
+ def test_backend_delete(self):
+ backend = self._backend()
+ backend.set("some_key", "some value")
+ backend.delete("some_key")
+ eq_(backend.get("some_key"), NO_VALUE)
+
+ def test_region_set_get_value(self):
reg = self._region()
reg.set("some key", "some value")
eq_(reg.get("some key"), "some value")
- def test_set_get_nothing(self):
+ def test_region_set_get_nothing(self):
reg = self._region()
eq_(reg.get("some key"), NO_VALUE)
- def test_creator(self):
+ def test_region_creator(self):
reg = self._region()
def creator():
return "some value"
eq_(reg.get_or_create("some key", creator), "some value")
- def test_remove(self):
+ def test_threaded_dogpile(self):
+ # run a basic dogpile concurrency test.
+ # note the concurrency of dogpile itself
+ # is intensively tested as part of dogpile.
+ reg = self._region(config_args={"expiration_time":.25})
+ lock = Lock()
+ canary = []
+ def creator():
+ ack = lock.acquire(False)
+ canary.append(ack)
+ time.sleep(.5)
+ if ack:
+ lock.release()
+ return "some value"
+ def f():
+ for x in xrange(5):
+ reg.get_or_create("some key", creator)
+ time.sleep(.5)
+
+ threads = [Thread(target=f) for i in xrange(5)]
+ for t in threads:
+ t.start()
+ for t in threads:
+ t.join()
+ assert len(canary) > 3
+ assert False not in canary
+
+ def test_region_delete(self):
reg = self._region()
reg.set("some key", "some value")
reg.delete("some key")
reg.delete("some key")
eq_(reg.get("some key"), NO_VALUE)
- def test_expire(self):
- reg = self._region(config_args={"expiration_time":1})
+ def test_region_expire(self):
+ reg = self._region(config_args={"expiration_time":.25})
counter = itertools.count(1)
def creator():
return "some value %d" % next(counter)
eq_(reg.get_or_create("some key", creator), "some value 1")
- time.sleep(1)
+ time.sleep(.4)
eq_(reg.get("some key"), "some value 1")
eq_(reg.get_or_create("some key", creator), "some value 2")
eq_(reg.get("some key"), "some value 2")
+
+class _GenericMutexTest(_GenericBackendFixture, TestCase):
+ def test_mutex(self):
+ backend = self._backend()
+ mutex = backend.get_mutex("foo")
+
+ ac = mutex.acquire()
+ assert ac
+ ac2 = mutex.acquire(wait=False)
+ assert not ac2
+ mutex.release()
+ ac3 = mutex.acquire()
+ assert ac3
+ mutex.release()
+
+ def test_mutex_threaded(self):
+ backend = self._backend()
+ mutex = backend.get_mutex("foo")
+
+ lock = Lock()
+ canary = []
+ def f():
+ for x in xrange(5):
+ mutex = backend.get_mutex("foo")
+ mutex.acquire()
+ for y in xrange(5):
+ ack = lock.acquire(False)
+ canary.append(ack)
+ time.sleep(.002)
+ if ack:
+ lock.release()
+ mutex.release()
+ time.sleep(.02)
+
+ threads = [Thread(target=f) for i in xrange(5)]
+ for t in threads:
+ t.start()
+ for t in threads:
+ t.join()
+ assert False not in canary