use random keys for tests

observing key collisions among workers, so make sure each test
uses a unique key

Change-Id: Iad87a35bd0fbd30d98e6d1f8d563dfffa81c4e5a

Author: zzzeek

tests/cache/_fixtures.py

@@ -21,6 +21,10 @@
 from . import eq_
 
 
+def gen_some_key():
+    return f"some_key_{random.randint(1, 100000)}"
+
+
 class _GenericBackendFixture(object):
     @classmethod
     def setup_class(cls):
@@ -33,12 +37,13 @@ def setup_class(cls):
         cls._check_backend_available(backend)
 
     def tearDown(self):
+        some_key = gen_some_key()
         if self._region_inst:
             for key in self._keys:
                 self._region_inst.delete(key)
             self._keys.clear()
         elif self._backend_inst:
-            self._backend_inst.delete("some_key")
+            self._backend_inst.delete(some_key)
 
     @classmethod
     def _check_backend_available(cls, backend):
@@ -94,22 +99,26 @@ def _backend(self):
 class _GenericBackendTest(_GenericBackendFixture, TestCase):
     def test_backend_get_nothing(self):
         backend = self._backend()
-        eq_(backend.get_serialized("some_key"), NO_VALUE)
+        some_key = gen_some_key()
+        eq_(backend.get_serialized(some_key), NO_VALUE)
 
     def test_backend_delete_nothing(self):
         backend = self._backend()
-        backend.delete("some_key")
+        some_key = gen_some_key()
+        backend.delete(some_key)
 
     def test_backend_set_get_value(self):
         backend = self._backend()
-        backend.set_serialized("some_key", b"some value")
-        eq_(backend.get_serialized("some_key"), b"some value")
+        some_key = gen_some_key()
+        backend.set_serialized(some_key, b"some value")
+        eq_(backend.get_serialized(some_key), b"some value")
 
     def test_backend_delete(self):
         backend = self._backend()
-        backend.set_serialized("some_key", b"some value")
-        backend.delete("some_key")
-        eq_(backend.get_serialized("some_key"), NO_VALUE)
+        some_key = gen_some_key()
+        backend.set_serialized(some_key, b"some value")
+        backend.delete(some_key)
+        eq_(backend.get_serialized(some_key), NO_VALUE)
 
     def test_region_is_key_locked(self):
         reg = self._region()
@@ -128,8 +137,9 @@ def test_region_is_key_locked(self):
 
     def test_region_set_get_value(self):
         reg = self._region()
-        reg.set("some key", "some value")
-        eq_(reg.get("some key"), "some value")
+        some_key = gen_some_key()
+        reg.set(some_key, "some value")
+        eq_(reg.get(some_key), "some value")
 
     def test_region_set_multiple_values(self):
         reg = self._region()
@@ -202,16 +212,18 @@ def test_region_delete_multiple(self):
 
     def test_region_set_get_nothing(self):
         reg = self._region()
-        reg.delete_multi(["some key"])
-        eq_(reg.get("some key"), NO_VALUE)
+        some_key = gen_some_key()
+        reg.delete_multi([some_key])
+        eq_(reg.get(some_key), NO_VALUE)
 
     def test_region_creator(self):
         reg = self._region()
 
         def creator():
             return "some value"
 
-        eq_(reg.get_or_create("some key", creator), "some value")
+        some_key = gen_some_key()
+        eq_(reg.get_or_create(some_key, creator), "some value")
 
     @pytest.mark.time_intensive
     def test_threaded_dogpile(self):
@@ -221,6 +233,7 @@ def test_threaded_dogpile(self):
         reg = self._region(config_args={"expiration_time": 0.25})
         lock = Lock()
         canary = []
+        some_key = gen_some_key()
 
         def creator():
             ack = lock.acquire(False)
@@ -232,7 +245,7 @@ def creator():
 
         def f():
             for x in range(5):
-                reg.get_or_create("some key", creator)
+                reg.get_or_create(some_key, creator)
                 time.sleep(0.5)
 
         threads = [Thread(target=f) for i in range(10)]
@@ -253,8 +266,9 @@ def test_threaded_get_multi(self):
         With "distributed" locks, this is not 100% the case.
 
         """
+        some_key = gen_some_key()
         reg = self._region(config_args={"expiration_time": 0.25})
-        backend_mutex = reg.backend.get_mutex("some_key")
+        backend_mutex = reg.backend.get_mutex(some_key)
         is_custom_mutex = backend_mutex is not None
 
         locks = dict((str(i), Lock()) for i in range(11))
@@ -310,10 +324,11 @@ def f():
 
     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)
+        some_key = gen_some_key()
+        reg.set(some_key, "some value")
+        reg.delete(some_key)
+        reg.delete(some_key)
+        eq_(reg.get(some_key), NO_VALUE)
 
     @pytest.mark.time_intensive
     def test_region_expire(self):
@@ -324,6 +339,7 @@ def test_region_expire(self):
         # with very slow processing missing a timeout, as is often the
         # case with this particular test
 
+        some_key = gen_some_key()
         expire_time = 1.00
 
         reg = self._region(config_args={"expiration_time": expire_time})
@@ -332,18 +348,18 @@ def test_region_expire(self):
         def creator():
             return "some value %d" % next(counter)
 
-        eq_(reg.get_or_create("some key", creator), "some value 1")
+        eq_(reg.get_or_create(some_key, creator), "some value 1")
         time.sleep(expire_time + (0.2 * expire_time))
         # expiration is definitely hit
-        post_expiration = reg.get("some key", ignore_expiration=True)
+        post_expiration = reg.get(some_key, ignore_expiration=True)
         if post_expiration is not NO_VALUE:
             eq_(post_expiration, "some value 1")
 
-        eq_(reg.get_or_create("some key", creator), "some value 2")
+        eq_(reg.get_or_create(some_key, creator), "some value 2")
 
         # this line needs to run less the expire_time sec before the previous
         # two or it hits the expiration
-        eq_(reg.get("some key"), "some value 2")
+        eq_(reg.get(some_key), "some value 2")
 
     def test_decorated_fn_functionality(self):
         # test for any quirks in the fn decoration that interact
@@ -371,13 +387,14 @@ def my_function(x, y):
         eq_(my_function(4, 3), 11)
 
     def test_exploding_value_fn(self):
+        some_key = gen_some_key()
         reg = self._region()
 
         def boom():
             raise Exception("boom")
 
         assert_raises_message(
-            Exception, "boom", reg.get_or_create, "some_key", boom
+            Exception, "boom", reg.get_or_create, some_key, boom
         )