In unit tests, explicitly pass in the Redis client (#300)

This is the first step toward using a separate Redis database for unit
tests, for easier cleanup.

tests/test_base.py

@@ -34,13 +34,24 @@ def test_random_key_raises_randomkeyerror_when_no_tries_left(self):
 class _BaseTestCase(TestCase):
     def setUp(self):
         super().setUp()
-        self.raj = RedisDict(key='pottery:raj', hobby='music', vegetarian=True)
+        self.raj = RedisDict(
+            redis=self.redis,
+            key='pottery:raj',
+            hobby='music',
+            vegetarian=True,
+        )
         self.nilika = RedisDict(
+            redis=self.redis,
             key='pottery:nilika',
             hobby='music',
             vegetarian=True,
         )
-        self.luvh = RedisDict(key='luvh', hobby='bullying', vegetarian=False)
+        self.luvh = RedisDict(
+            redis=self.redis,
+            key='luvh',
+            hobby='bullying',
+            vegetarian=False,
+        )
 
     def tearDown(self):
         self.redis.delete('luvh')
@@ -50,7 +61,7 @@ def tearDown(self):
 class CommonTests(_BaseTestCase):
     def test_out_of_scope(self):
         def scope():
-            raj = RedisDict(hobby='music', vegetarian=True)
+            raj = RedisDict(redis=self.redis, hobby='music', vegetarian=True)
             assert self.redis.exists(raj.key)
             return raj.key
 

tests/test_bloom.py

@@ -19,7 +19,11 @@ class BloomFilterTests(TestCase):
 
     def test_init_without_iterable(self):
         'Test BloomFilter.__init__() without an iterable for initialization'
-        dilberts = BloomFilter(num_elements=100, false_positives=0.01)
+        dilberts = BloomFilter(
+            redis=self.redis,
+            num_elements=100,
+            false_positives=0.01,
+        )
         assert dilberts.num_elements == 100
         assert dilberts.false_positives == 0.01
         assert 'rajiv' not in dilberts
@@ -33,6 +37,7 @@ def test_init_with_iterable(self):
         'Test BloomFilter.__init__() with an iterable for initialization'
         dilberts = BloomFilter(
             {'rajiv', 'raj'},
+            redis=self.redis,
             num_elements=100,
             false_positives=0.01,
         )
@@ -51,25 +56,45 @@ def test_init_with_iterable(self):
 
     def test_size_and_num_hashes(self):
         'Test BloomFilter.size()'
-        dilberts = BloomFilter(num_elements=100, false_positives=0.1)
+        dilberts = BloomFilter(
+            redis=self.redis,
+            num_elements=100,
+            false_positives=0.1,
+        )
         assert dilberts.size() == 480
         assert dilberts.num_hashes() == 4
 
-        dilberts = BloomFilter(num_elements=1000, false_positives=0.1)
+        dilberts = BloomFilter(
+            redis=self.redis,
+            num_elements=1000,
+            false_positives=0.1,
+        )
         assert dilberts.size() == 4793
         assert dilberts.num_hashes() == 4
 
-        dilberts = BloomFilter(num_elements=100, false_positives=0.01)
+        dilberts = BloomFilter(
+            redis=self.redis,
+            num_elements=100,
+            false_positives=0.01,
+        )
         assert dilberts.size() == 959
         assert dilberts.num_hashes() == 7
 
-        dilberts = BloomFilter(num_elements=1000, false_positives=0.01)
+        dilberts = BloomFilter(
+            redis=self.redis,
+            num_elements=1000,
+            false_positives=0.01,
+        )
         assert dilberts.size() == 9586
         assert dilberts.num_hashes() == 7
 
     def test_add(self):
         'Test BloomFilter add(), __contains__(), and __len__()'
-        dilberts = BloomFilter(num_elements=100, false_positives=0.01)
+        dilberts = BloomFilter(
+            redis=self.redis,
+            num_elements=100,
+            false_positives=0.01,
+        )
         assert 'rajiv' not in dilberts
         assert 'raj' not in dilberts
         assert 'dan' not in dilberts
@@ -120,7 +145,11 @@ def test_add(self):
 
     def test_update(self):
         'Test BloomFilter update(), __contains__(), and __len__()'
-        dilberts = BloomFilter(num_elements=100, false_positives=0.01)
+        dilberts = BloomFilter(
+            redis=self.redis,
+            num_elements=100,
+            false_positives=0.01,
+        )
         assert 'rajiv' not in dilberts
         assert 'raj' not in dilberts
         assert 'dan' not in dilberts
@@ -163,9 +192,10 @@ def test_update(self):
     def test_repr(self):
         'Test BloomFilter.__repr__()'
         dilberts = BloomFilter(
+            redis=self.redis,
+            key=self._KEY,
             num_elements=100,
             false_positives=0.01,
-            key=self._KEY,
         )
         assert repr(dilberts) == f'<BloomFilter key={self._KEY}>'
 
@@ -195,9 +225,10 @@ def setUp(self):
         # Initialize the recently consumed Bloom filter on the seen set.
         self.recently_consumed = BloomFilter(
             self.seen_links,
+            redis=self.redis,
+            key=self._KEY,
             num_elements=1000,
             false_positives=0.001,
-            key=self._KEY,
         )
 
     def tearDown(self):

tests/test_cache.py

@@ -25,6 +25,22 @@ class CacheDecoratorTests(TestCase):
 
     def setUp(self):
         super().setUp()
+
+        def expensive_method(*args, **kwargs):
+            'getrandbits(16) -> x.  Generates a 16-bit random int.'
+            return random.getrandbits(16)
+
+        self.expensive_method_expiration = redis_cache(
+            redis=self.redis,
+            key=self._KEY_EXPIRATION,
+        )(expensive_method)
+
+        self.expensive_method_no_expiration = redis_cache(
+            redis=self.redis,
+            key=self._KEY_NO_EXPIRATION,
+            timeout=None,
+        )(expensive_method)
+
         self.expensive_method_expiration.cache_clear()
         self.expensive_method_no_expiration.cache_clear()
 
@@ -33,18 +49,6 @@ def tearDown(self):
         self.expensive_method_no_expiration.cache_clear()
         super().tearDown()
 
-    @staticmethod
-    @redis_cache(key=_KEY_EXPIRATION)
-    def expensive_method_expiration(*args, **kwargs):
-        'getrandbits(16) -> x.  Generates a 16-bit random int.'
-        return random.getrandbits(16)
-
-    @staticmethod
-    @redis_cache(key=_KEY_NO_EXPIRATION, timeout=None)
-    def expensive_method_no_expiration(*args, **kwargs):
-        'getrandbits(16) -> x.  Generates a 16-bit random int.'
-        return random.getrandbits(16)
-
     def test_cache(self):
         assert self.expensive_method_expiration.cache_info() == CacheInfo(
             hits=0,