Used more precise assertions in cache tests

tests/cache/tests.py

@@ -72,18 +72,18 @@ class DummyCacheTests(TestCase):
     def test_simple(self):
         "Dummy cache backend ignores cache set calls"
         cache.set("key", "value")
-        self.assertEqual(cache.get("key"), None)
+        self.assertIsNone(cache.get("key"))
 
     def test_add(self):
         "Add doesn't do anything in dummy cache backend"
         cache.add("addkey1", "value")
         result = cache.add("addkey1", "newvalue")
-        self.assertEqual(result, True)
-        self.assertEqual(cache.get("addkey1"), None)
+        self.assertTrue(result)
+        self.assertIsNone(cache.get("addkey1"))
 
     def test_non_existent(self):
         "Non-existent keys aren't found in the dummy cache backend"
-        self.assertEqual(cache.get("does_not_exist"), None)
+        self.assertIsNone(cache.get("does_not_exist"))
         self.assertEqual(cache.get("does_not_exist", "bang!"), "bang!")
 
     def test_get_many(self):
@@ -99,22 +99,22 @@ class DummyCacheTests(TestCase):
         "Cache deletion is transparently ignored on the dummy cache backend"
         cache.set("key1", "spam")
         cache.set("key2", "eggs")
-        self.assertEqual(cache.get("key1"), None)
+        self.assertIsNone(cache.get("key1"))
         cache.delete("key1")
-        self.assertEqual(cache.get("key1"), None)
-        self.assertEqual(cache.get("key2"), None)
+        self.assertIsNone(cache.get("key1"))
+        self.assertIsNone(cache.get("key2"))
 
     def test_has_key(self):
         "The has_key method doesn't ever return True for the dummy cache backend"
         cache.set("hello1", "goodbye1")
-        self.assertEqual(cache.has_key("hello1"), False)
-        self.assertEqual(cache.has_key("goodbye1"), False)
+        self.assertFalse(cache.has_key("hello1"))
+        self.assertFalse(cache.has_key("goodbye1"))
 
     def test_in(self):
         "The in operator doesn't ever return True for the dummy cache backend"
         cache.set("hello2", "goodbye2")
-        self.assertEqual("hello2" in cache, False)
-        self.assertEqual("goodbye2" in cache, False)
+        self.assertNotIn("hello2", cache)
+        self.assertNotIn("goodbye2", cache)
 
     def test_incr(self):
         "Dummy cache values can't be incremented"
@@ -140,7 +140,7 @@ class DummyCacheTests(TestCase):
             'class': C,
         }
         cache.set("stuff", stuff)
-        self.assertEqual(cache.get("stuff"), None)
+        self.assertIsNone(cache.get("stuff"))
 
     def test_expiration(self):
         "Expiration has no effect on the dummy cache"
@@ -149,11 +149,11 @@ class DummyCacheTests(TestCase):
         cache.set('expire3', 'very quickly', 1)
 
         time.sleep(2)
-        self.assertEqual(cache.get("expire1"), None)
+        self.assertIsNone(cache.get("expire1"))
 
         cache.add("expire2", "newvalue")
-        self.assertEqual(cache.get("expire2"), None)
-        self.assertEqual(cache.has_key("expire3"), False)
+        self.assertIsNone(cache.get("expire2"))
+        self.assertFalse(cache.has_key("expire3"))
 
     def test_unicode(self):
         "Unicode values are ignored by the dummy cache"
@@ -165,7 +165,7 @@ class DummyCacheTests(TestCase):
         }
         for (key, value) in stuff.items():
             cache.set(key, value)
-            self.assertEqual(cache.get(key), None)
+            self.assertIsNone(cache.get(key))
 
     def test_set_many(self):
         "set_many does nothing for the dummy cache backend"
@@ -241,7 +241,7 @@ class BaseCacheTests(object):
         # A key can be added to a cache
         cache.add("addkey1", "value")
         result = cache.add("addkey1", "newvalue")
-        self.assertEqual(result, False)
+        self.assertFalse(result)
         self.assertEqual(cache.get("addkey1"), "value")
 
     def test_prefix(self):
@@ -259,7 +259,7 @@ class BaseCacheTests(object):
     def test_non_existent(self):
         # Non-existent cache keys return as None/default
         # get with non-existent keys
-        self.assertEqual(cache.get("does_not_exist"), None)
+        self.assertIsNone(cache.get("does_not_exist"))
         self.assertEqual(cache.get("does_not_exist", "bang!"), "bang!")
 
     def test_get_many(self):
@@ -268,8 +268,8 @@ class BaseCacheTests(object):
         cache.set('b', 'b')
         cache.set('c', 'c')
         cache.set('d', 'd')
-        self.assertEqual(cache.get_many(['a', 'c', 'd']), {'a': 'a', 'c': 'c', 'd': 'd'})
-        self.assertEqual(cache.get_many(['a', 'b', 'e']), {'a': 'a', 'b': 'b'})
+        self.assertDictEqual(cache.get_many(['a', 'c', 'd']), {'a': 'a', 'c': 'c', 'd': 'd'})
+        self.assertDictEqual(cache.get_many(['a', 'b', 'e']), {'a': 'a', 'b': 'b'})
 
     def test_delete(self):
         # Cache keys can be deleted
@@ -277,22 +277,22 @@ class BaseCacheTests(object):
         cache.set("key2", "eggs")
         self.assertEqual(cache.get("key1"), "spam")
         cache.delete("key1")
-        self.assertEqual(cache.get("key1"), None)
+        self.assertIsNone(cache.get("key1"))
         self.assertEqual(cache.get("key2"), "eggs")
 
     def test_has_key(self):
         # The cache can be inspected for cache keys
         cache.set("hello1", "goodbye1")
-        self.assertEqual(cache.has_key("hello1"), True)
-        self.assertEqual(cache.has_key("goodbye1"), False)
+        self.assertTrue(cache.has_key("hello1"))
+        self.assertFalse(cache.has_key("goodbye1"))
         cache.set("no_expiry", "here", None)
-        self.assertEqual(cache.has_key("no_expiry"), True)
+        self.assertTrue(cache.has_key("no_expiry"))
 
     def test_in(self):
         # The in operator can be used to inspect cache contents
         cache.set("hello2", "goodbye2")
-        self.assertEqual("hello2" in cache, True)
-        self.assertEqual("goodbye2" in cache, False)
+        self.assertIn("hello2", cache)
+        self.assertNotIn("goodbye2", cache)
 
     def test_incr(self):
         # Cache values can be incremented
@@ -380,11 +380,11 @@ class BaseCacheTests(object):
         cache.set('expire3', 'very quickly', 1)
 
         time.sleep(2)
-        self.assertEqual(cache.get("expire1"), None)
+        self.assertIsNone(cache.get("expire1"))
 
         cache.add("expire2", "newvalue")
         self.assertEqual(cache.get("expire2"), "newvalue")
-        self.assertEqual(cache.has_key("expire3"), False)
+        self.assertFalse(cache.has_key("expire3"))
 
     def test_unicode(self):
         # Unicode values can be cached
@@ -446,8 +446,8 @@ class BaseCacheTests(object):
         # set_many takes a second ``timeout`` parameter
         cache.set_many({"key1": "spam", "key2": "eggs"}, 1)
         time.sleep(2)
-        self.assertEqual(cache.get("key1"), None)
-        self.assertEqual(cache.get("key2"), None)
+        self.assertIsNone(cache.get("key1"))
+        self.assertIsNone(cache.get("key2"))
 
     def test_delete_many(self):
         # Multiple keys can be deleted using delete_many
@@ -455,8 +455,8 @@ class BaseCacheTests(object):
         cache.set("key2", "eggs")
         cache.set("key3", "ham")
         cache.delete_many(["key1", "key2"])
-        self.assertEqual(cache.get("key1"), None)
-        self.assertEqual(cache.get("key2"), None)
+        self.assertIsNone(cache.get("key1"))
+        self.assertIsNone(cache.get("key2"))
         self.assertEqual(cache.get("key3"), "ham")
 
     def test_clear(self):
@@ -464,8 +464,8 @@ class BaseCacheTests(object):
         cache.set("key1", "spam")
         cache.set("key2", "eggs")
         cache.clear()
-        self.assertEqual(cache.get("key1"), None)
-        self.assertEqual(cache.get("key2"), None)
+        self.assertIsNone(cache.get("key1"))
+        self.assertIsNone(cache.get("key2"))
 
     def test_long_timeout(self):
         '''
@@ -505,14 +505,14 @@ class BaseCacheTests(object):
         Passing in zero into timeout results in a value that is not cached
         '''
         cache.set('key1', 'eggs', 0)
-        self.assertEqual(cache.get('key1'), None)
+        self.assertIsNone(cache.get('key1'))
 
         cache.add('key2', 'ham', 0)
-        self.assertEqual(cache.get('key2'), None)
+        self.assertIsNone(cache.get('key2'))
 
         cache.set_many({'key3': 'sausage', 'key4': 'lobster bisque'}, 0)
-        self.assertEqual(cache.get('key3'), None)
-        self.assertEqual(cache.get('key4'), None)
+        self.assertIsNone(cache.get('key3'))
+        self.assertIsNone(cache.get('key4'))
 
     def test_float_timeout(self):
         # Make sure a timeout given as a float doesn't crash anything.
@@ -574,51 +574,51 @@ class BaseCacheTests(object):
         cache.set('answer1', 42)
         self.assertEqual(cache.get('answer1'), 42)
         self.assertEqual(cache.get('answer1', version=1), 42)
-        self.assertEqual(cache.get('answer1', version=2), None)
+        self.assertIsNone(cache.get('answer1', version=2))
 
-        self.assertEqual(caches['v2'].get('answer1'), None)
+        self.assertIsNone(caches['v2'].get('answer1'))
         self.assertEqual(caches['v2'].get('answer1', version=1), 42)
-        self.assertEqual(caches['v2'].get('answer1', version=2), None)
+        self.assertIsNone(caches['v2'].get('answer1', version=2))
 
         # set, default version = 1, but manually override version = 2
         cache.set('answer2', 42, version=2)
-        self.assertEqual(cache.get('answer2'), None)
-        self.assertEqual(cache.get('answer2', version=1), None)
+        self.assertIsNone(cache.get('answer2'))
+        self.assertIsNone(cache.get('answer2', version=1))
         self.assertEqual(cache.get('answer2', version=2), 42)
 
         self.assertEqual(caches['v2'].get('answer2'), 42)
-        self.assertEqual(caches['v2'].get('answer2', version=1), None)
+        self.assertIsNone(caches['v2'].get('answer2', version=1))
         self.assertEqual(caches['v2'].get('answer2', version=2), 42)
 
         # v2 set, using default version = 2
         caches['v2'].set('answer3', 42)
-        self.assertEqual(cache.get('answer3'), None)
-        self.assertEqual(cache.get('answer3', version=1), None)
+        self.assertIsNone(cache.get('answer3'))
+        self.assertIsNone(cache.get('answer3', version=1))
         self.assertEqual(cache.get('answer3', version=2), 42)
 
         self.assertEqual(caches['v2'].get('answer3'), 42)
-        self.assertEqual(caches['v2'].get('answer3', version=1), None)
+        self.assertIsNone(caches['v2'].get('answer3', version=1))
         self.assertEqual(caches['v2'].get('answer3', version=2), 42)
 
         # v2 set, default version = 2, but manually override version = 1
         caches['v2'].set('answer4', 42, version=1)
         self.assertEqual(cache.get('answer4'), 42)
         self.assertEqual(cache.get('answer4', version=1), 42)
-        self.assertEqual(cache.get('answer4', version=2), None)
+        self.assertIsNone(cache.get('answer4', version=2))
 
-        self.assertEqual(caches['v2'].get('answer4'), None)
+        self.assertIsNone(caches['v2'].get('answer4'))
         self.assertEqual(caches['v2'].get('answer4', version=1), 42)
-        self.assertEqual(caches['v2'].get('answer4', version=2), None)
+        self.assertIsNone(caches['v2'].get('answer4', version=2))
 
     def test_cache_versioning_add(self):
 
         # add, default version = 1, but manually override version = 2
         cache.add('answer1', 42, version=2)
-        self.assertEqual(cache.get('answer1', version=1), None)
+        self.assertIsNone(cache.get('answer1', version=1))
         self.assertEqual(cache.get('answer1', version=2), 42)
 
         cache.add('answer1', 37, version=2)
-        self.assertEqual(cache.get('answer1', version=1), None)
+        self.assertIsNone(cache.get('answer1', version=1))
         self.assertEqual(cache.get('answer1', version=2), 42)
 
         cache.add('answer1', 37, version=1)
@@ -627,11 +627,11 @@ class BaseCacheTests(object):
 
         # v2 add, using default version = 2
         caches['v2'].add('answer2', 42)
-        self.assertEqual(cache.get('answer2', version=1), None)
+        self.assertIsNone(cache.get('answer2', version=1))
         self.assertEqual(cache.get('answer2', version=2), 42)
 
         caches['v2'].add('answer2', 37)
-        self.assertEqual(cache.get('answer2', version=1), None)
+        self.assertIsNone(cache.get('answer2', version=1))
         self.assertEqual(cache.get('answer2', version=2), 42)
 
         caches['v2'].add('answer2', 37, version=1)
@@ -641,11 +641,11 @@ class BaseCacheTests(object):
         # v2 add, default version = 2, but manually override version = 1
         caches['v2'].add('answer3', 42, version=1)
         self.assertEqual(cache.get('answer3', version=1), 42)
-        self.assertEqual(cache.get('answer3', version=2), None)
+        self.assertIsNone(cache.get('answer3', version=2))
 
         caches['v2'].add('answer3', 37, version=1)
         self.assertEqual(cache.get('answer3', version=1), 42)
-        self.assertEqual(cache.get('answer3', version=2), None)
+        self.assertIsNone(cache.get('answer3', version=2))
 
         caches['v2'].add('answer3', 37)
         self.assertEqual(cache.get('answer3', version=1), 42)
@@ -667,25 +667,25 @@ class BaseCacheTests(object):
         cache.set('answer1', 37, version=1)
         cache.set('answer1', 42, version=2)
         cache.delete('answer1')
-        self.assertEqual(cache.get('answer1', version=1), None)
+        self.assertIsNone(cache.get('answer1', version=1))
         self.assertEqual(cache.get('answer1', version=2), 42)
 
         cache.set('answer2', 37, version=1)
         cache.set('answer2', 42, version=2)
         cache.delete('answer2', version=2)
         self.assertEqual(cache.get('answer2', version=1), 37)
-        self.assertEqual(cache.get('answer2', version=2), None)
+        self.assertIsNone(cache.get('answer2', version=2))
 
         cache.set('answer3', 37, version=1)
         cache.set('answer3', 42, version=2)
         caches['v2'].delete('answer3')
         self.assertEqual(cache.get('answer3', version=1), 37)
-        self.assertEqual(cache.get('answer3', version=2), None)
+        self.assertIsNone(cache.get('answer3', version=2))
 
         cache.set('answer4', 37, version=1)
         cache.set('answer4', 42, version=2)
         caches['v2'].delete('answer4', version=1)
-        self.assertEqual(cache.get('answer4', version=1), None)
+        self.assertIsNone(cache.get('answer4', version=1))
         self.assertEqual(cache.get('answer4', version=2), 42)
 
     def test_cache_versioning_incr_decr(self):
@@ -728,103 +728,103 @@ class BaseCacheTests(object):
     def test_cache_versioning_get_set_many(self):
         # set, using default version = 1
         cache.set_many({'ford1': 37, 'arthur1': 42})
-        self.assertEqual(cache.get_many(['ford1', 'arthur1']),
+        self.assertDictEqual(cache.get_many(['ford1', 'arthur1']),
                          {'ford1': 37, 'arthur1': 42})
-        self.assertEqual(cache.get_many(['ford1', 'arthur1'], version=1),
+        self.assertDictEqual(cache.get_many(['ford1', 'arthur1'], version=1),
                          {'ford1': 37, 'arthur1': 42})
-        self.assertEqual(cache.get_many(['ford1', 'arthur1'], version=2), {})
+        self.assertDictEqual(cache.get_many(['ford1', 'arthur1'], version=2), {})
 
-        self.assertEqual(caches['v2'].get_many(['ford1', 'arthur1']), {})
-        self.assertEqual(caches['v2'].get_many(['ford1', 'arthur1'], version=1),
+        self.assertDictEqual(caches['v2'].get_many(['ford1', 'arthur1']), {})
+        self.assertDictEqual(caches['v2'].get_many(['ford1', 'arthur1'], version=1),
                          {'ford1': 37, 'arthur1': 42})
-        self.assertEqual(caches['v2'].get_many(['ford1', 'arthur1'], version=2), {})
+        self.assertDictEqual(caches['v2'].get_many(['ford1', 'arthur1'], version=2), {})
 
         # set, default version = 1, but manually override version = 2
         cache.set_many({'ford2': 37, 'arthur2': 42}, version=2)
-        self.assertEqual(cache.get_many(['ford2', 'arthur2']), {})
-        self.assertEqual(cache.get_many(['ford2', 'arthur2'], version=1), {})
-        self.assertEqual(cache.get_many(['ford2', 'arthur2'], version=2),
+        self.assertDictEqual(cache.get_many(['ford2', 'arthur2']), {})
+        self.assertDictEqual(cache.get_many(['ford2', 'arthur2'], version=1), {})
+        self.assertDictEqual(cache.get_many(['ford2', 'arthur2'], version=2),
                          {'ford2': 37, 'arthur2': 42})
 
-        self.assertEqual(caches['v2'].get_many(['ford2', 'arthur2']),
+        self.assertDictEqual(caches['v2'].get_many(['ford2', 'arthur2']),
                          {'ford2': 37, 'arthur2': 42})
-        self.assertEqual(caches['v2'].get_many(['ford2', 'arthur2'], version=1), {})
-        self.assertEqual(caches['v2'].get_many(['ford2', 'arthur2'], version=2),
+        self.assertDictEqual(caches['v2'].get_many(['ford2', 'arthur2'], version=1), {})
+        self.assertDictEqual(caches['v2'].get_many(['ford2', 'arthur2'], version=2),
                          {'ford2': 37, 'arthur2': 42})
 
         # v2 set, using default version = 2
         caches['v2'].set_many({'ford3': 37, 'arthur3': 42})
-        self.assertEqual(cache.get_many(['ford3', 'arthur3']), {})
-        self.assertEqual(cache.get_many(['ford3', 'arthur3'], version=1), {})
-        self.assertEqual(cache.get_many(['ford3', 'arthur3'], version=2),
+        self.assertDictEqual(cache.get_many(['ford3', 'arthur3']), {})
+        self.assertDictEqual(cache.get_many(['ford3', 'arthur3'], version=1), {})
+        self.assertDictEqual(cache.get_many(['ford3', 'arthur3'], version=2),
                          {'ford3': 37, 'arthur3': 42})
 
-        self.assertEqual(caches['v2'].get_many(['ford3', 'arthur3']),
+        self.assertDictEqual(caches['v2'].get_many(['ford3', 'arthur3']),
                          {'ford3': 37, 'arthur3': 42})
-        self.assertEqual(caches['v2'].get_many(['ford3', 'arthur3'], version=1), {})
-        self.assertEqual(caches['v2'].get_many(['ford3', 'arthur3'], version=2),
+        self.assertDictEqual(caches['v2'].get_many(['ford3', 'arthur3'], version=1), {})
+        self.assertDictEqual(caches['v2'].get_many(['ford3', 'arthur3'], version=2),
                          {'ford3': 37, 'arthur3': 42})
 
         # v2 set, default version = 2, but manually override version = 1
         caches['v2'].set_many({'ford4': 37, 'arthur4': 42}, version=1)
-        self.assertEqual(cache.get_many(['ford4', 'arthur4']),
+        self.assertDictEqual(cache.get_many(['ford4', 'arthur4']),
                          {'ford4': 37, 'arthur4': 42})
-        self.assertEqual(cache.get_many(['ford4', 'arthur4'], version=1),
+        self.assertDictEqual(cache.get_many(['ford4', 'arthur4'], version=1),
                          {'ford4': 37, 'arthur4': 42})
-        self.assertEqual(cache.get_many(['ford4', 'arthur4'], version=2), {})
+        self.assertDictEqual(cache.get_many(['ford4', 'arthur4'], version=2), {})
 
-        self.assertEqual(caches['v2'].get_many(['ford4', 'arthur4']), {})
-        self.assertEqual(caches['v2'].get_many(['ford4', 'arthur4'], version=1),
+        self.assertDictEqual(caches['v2'].get_many(['ford4', 'arthur4']), {})
+        self.assertDictEqual(caches['v2'].get_many(['ford4', 'arthur4'], version=1),
                          {'ford4': 37, 'arthur4': 42})
-        self.assertEqual(caches['v2'].get_many(['ford4', 'arthur4'], version=2), {})
+        self.assertDictEqual(caches['v2'].get_many(['ford4', 'arthur4'], version=2), {})
 
     def test_incr_version(self):
         cache.set('answer', 42, version=2)
-        self.assertEqual(cache.get('answer'), None)
-        self.assertEqual(cache.get('answer', version=1), None)
+        self.assertIsNone(cache.get('answer'))
+        self.assertIsNone(cache.get('answer', version=1))
         self.assertEqual(cache.get('answer', version=2), 42)
-        self.assertEqual(cache.get('answer', version=3), None)
+        self.assertIsNone(cache.get('answer', version=3))
 
         self.assertEqual(cache.incr_version('answer', version=2), 3)
-        self.assertEqual(cache.get('answer'), None)
-        self.assertEqual(cache.get('answer', version=1), None)
-        self.assertEqual(cache.get('answer', version=2), None)
+        self.assertIsNone(cache.get('answer'))
+        self.assertIsNone(cache.get('answer', version=1))
+        self.assertIsNone(cache.get('answer', version=2))
         self.assertEqual(cache.get('answer', version=3), 42)
 
         caches['v2'].set('answer2', 42)
         self.assertEqual(caches['v2'].get('answer2'), 42)
-        self.assertEqual(caches['v2'].get('answer2', version=1), None)
+        self.assertIsNone(caches['v2'].get('answer2', version=1))
         self.assertEqual(caches['v2'].get('answer2', version=2), 42)
-        self.assertEqual(caches['v2'].get('answer2', version=3), None)
+        self.assertIsNone(caches['v2'].get('answer2', version=3))
 
         self.assertEqual(caches['v2'].incr_version('answer2'), 3)
-        self.assertEqual(caches['v2'].get('answer2'), None)
-        self.assertEqual(caches['v2'].get('answer2', version=1), None)
-        self.assertEqual(caches['v2'].get('answer2', version=2), None)
+        self.assertIsNone(caches['v2'].get('answer2'))
+        self.assertIsNone(caches['v2'].get('answer2', version=1))
+        self.assertIsNone(caches['v2'].get('answer2', version=2))
         self.assertEqual(caches['v2'].get('answer2', version=3), 42)
 
         self.assertRaises(ValueError, cache.incr_version, 'does_not_exist')
 
     def test_decr_version(self):
         cache.set('answer', 42, version=2)
-        self.assertEqual(cache.get('answer'), None)
-        self.assertEqual(cache.get('answer', version=1), None)
+        self.assertIsNone(cache.get('answer'))
+        self.assertIsNone(cache.get('answer', version=1))
         self.assertEqual(cache.get('answer', version=2), 42)
 
         self.assertEqual(cache.decr_version('answer', version=2), 1)
         self.assertEqual(cache.get('answer'), 42)
         self.assertEqual(cache.get('answer', version=1), 42)
-        self.assertEqual(cache.get('answer', version=2), None)
+        self.assertIsNone(cache.get('answer', version=2))
 
         caches['v2'].set('answer2', 42)
         self.assertEqual(caches['v2'].get('answer2'), 42)
-        self.assertEqual(caches['v2'].get('answer2', version=1), None)
+        self.assertIsNone(caches['v2'].get('answer2', version=1))
         self.assertEqual(caches['v2'].get('answer2', version=2), 42)
 
         self.assertEqual(caches['v2'].decr_version('answer2'), 1)
-        self.assertEqual(caches['v2'].get('answer2'), None)
+        self.assertIsNone(caches['v2'].get('answer2'))
         self.assertEqual(caches['v2'].get('answer2', version=1), 42)
-        self.assertEqual(caches['v2'].get('answer2', version=2), None)
+        self.assertIsNone(caches['v2'].get('answer2', version=2))
 
         self.assertRaises(ValueError, cache.decr_version, 'does_not_exist', version=2)
 
@@ -832,11 +832,11 @@ class BaseCacheTests(object):
         # Two caches with different key functions aren't visible to each other
         cache.set('answer1', 42)
         self.assertEqual(cache.get('answer1'), 42)
-        self.assertEqual(caches['custom_key'].get('answer1'), None)
-        self.assertEqual(caches['custom_key2'].get('answer1'), None)
+        self.assertIsNone(caches['custom_key'].get('answer1'))
+        self.assertIsNone(caches['custom_key2'].get('answer1'))
 
         caches['custom_key'].set('answer2', 42)
-        self.assertEqual(cache.get('answer2'), None)
+        self.assertIsNone(cache.get('answer2'))
         self.assertEqual(caches['custom_key'].get('answer2'), 42)
         self.assertEqual(caches['custom_key2'].get('answer2'), 42)
 
@@ -850,7 +850,7 @@ class BaseCacheTests(object):
         request = self.factory.get('/cache/test')
         request._cache_update_cache = True
         get_cache_data = FetchFromCacheMiddleware().process_request(request)
-        self.assertEqual(get_cache_data, None)
+        self.assertIsNone(get_cache_data)
 
         response = HttpResponse()
         content = 'Testing cookie serialization.'
@@ -860,13 +860,13 @@ class BaseCacheTests(object):
         update_middleware.process_response(request, response)
 
         get_cache_data = fetch_middleware.process_request(request)
-        self.assertNotEqual(get_cache_data, None)
+        self.assertIsNotNone(get_cache_data)
         self.assertEqual(get_cache_data.content, content.encode('utf-8'))
         self.assertEqual(get_cache_data.cookies, response.cookies)
 
         update_middleware.process_response(request, get_cache_data)
         get_cache_data = fetch_middleware.process_request(request)
-        self.assertNotEqual(get_cache_data, None)
+        self.assertIsNotNone(get_cache_data)
         self.assertEqual(get_cache_data.content, content.encode('utf-8'))
         self.assertEqual(get_cache_data.cookies, response.cookies)
 
@@ -941,7 +941,7 @@ class DBCacheTests(BaseCacheTests, TransactionTestCase):
         cache.set("key1", "spam")
         cache.clear()
         transaction.rollback()
-        self.assertEqual(cache.get("key1"), None)
+        self.assertIsNone(cache.get("key1"))
 
 
 @override_settings(USE_TZ=True)
@@ -1046,7 +1046,7 @@ class LocMemCacheTests(BaseCacheTests, TestCase):
         "Check that multiple locmem caches are isolated"
         cache.set('value', 42)
         self.assertEqual(caches['default'].get('value'), 42)
-        self.assertEqual(caches['other'].get('value'), None)
+        self.assertIsNone(caches['other'].get('value'))
 
     def test_locking_on_pickle(self):
         """#20613/#18541 -- Ensures pickling is done outside of the lock."""
@@ -1263,8 +1263,8 @@ class DefaultNonExpiringCacheKeyTests(TestCase):
         This means "no timeout".
         """
         cache = caches[DEFAULT_CACHE_ALIAS]
-        self.assertIs(None, cache.default_timeout)
-        self.assertEqual(None, cache.get_backend_timeout())
+        self.assertIsNone(cache.default_timeout)
+        self.assertIsNone(cache.get_backend_timeout())
 
     @override_settings(CACHES=DEFAULT_MEMORY_CACHES_SETTINGS)
     def test_caches_with_unset_timeout_set_expiring_key(self):
@@ -1276,7 +1276,7 @@ class DefaultNonExpiringCacheKeyTests(TestCase):
         cache = caches[DEFAULT_CACHE_ALIAS]
         cache.set(key, value)
         cache_key = cache.make_key(key)
-        self.assertNotEqual(None, cache._expire_info[cache_key])
+        self.assertIsNotNone(cache._expire_info[cache_key])
 
     @override_settings(CACHES=NEVER_EXPIRING_CACHES_SETTINGS)
     def text_caches_set_with_timeout_as_none_set_non_expiring_key(self):
@@ -1288,7 +1288,7 @@ class DefaultNonExpiringCacheKeyTests(TestCase):
         cache = caches[DEFAULT_CACHE_ALIAS]
         cache.set(key, value)
         cache_key = cache.make_key(key)
-        self.assertEqual(None, cache._expire_info[cache_key])
+        self.assertIsNone(cache._expire_info[cache_key])
 
 
 @override_settings(
@@ -1345,7 +1345,7 @@ class CacheUtils(TestCase):
         response = HttpResponse()
         key_prefix = 'localprefix'
         # Expect None if no headers have been set yet.
-        self.assertEqual(get_cache_key(request), None)
+        self.assertIsNone(get_cache_key(request))
         # Set headers to an empty list.
         learn_cache_key(request, response)
 
@@ -1366,7 +1366,7 @@ class CacheUtils(TestCase):
         request = self.factory.get(self.path, {'test': 1})
         response = HttpResponse()
         # Expect None if no headers have been set yet.
-        self.assertEqual(get_cache_key(request), None)
+        self.assertIsNone(get_cache_key(request))
         # Set headers to an empty list.
         learn_cache_key(request, response)
         # Verify that the querystring is taken into account.
@@ -1385,7 +1385,7 @@ class CacheUtils(TestCase):
         learn_cache_key(request1, HttpResponse())
         request2 = self.factory.get(self.path, HTTP_HOST='sub-2.example.com')
         learn_cache_key(request2, HttpResponse())
-        self.assertTrue(get_cache_key(request1) != get_cache_key(request2))
+        self.assertNotEqual(get_cache_key(request1), get_cache_key(request2))
 
     def test_learn_cache_key(self):
         request = self.factory.head(self.path)
@@ -1471,7 +1471,7 @@ class CacheHEADTest(TestCase):
         request = self.factory.head(self.path)
         request._cache_update_cache = True
         get_cache_data = FetchFromCacheMiddleware().process_request(request)
-        self.assertNotEqual(get_cache_data, None)
+        self.assertIsNotNone(get_cache_data)
         self.assertEqual(test_content.encode(), get_cache_data.content)
 
     def test_head_with_cached_get(self):
@@ -1483,7 +1483,7 @@ class CacheHEADTest(TestCase):
 
         request = self.factory.head(self.path)
         get_cache_data = FetchFromCacheMiddleware().process_request(request)
-        self.assertNotEqual(get_cache_data, None)
+        self.assertIsNotNone(get_cache_data)
         self.assertEqual(test_content.encode(), get_cache_data.content)
 
 
@@ -1660,20 +1660,20 @@ class CacheI18nTest(TestCase):
 
         get_cache_data = FetchFromCacheMiddleware().process_request(request)
         # first access, cache must return None
-        self.assertEqual(get_cache_data, None)
+        self.assertIsNone(get_cache_data)
         response = HttpResponse()
         content = 'Check for cache with QUERY_STRING'
         response.content = content
         UpdateCacheMiddleware().process_response(request, response)
         get_cache_data = FetchFromCacheMiddleware().process_request(request)
         # cache must return content
-        self.assertNotEqual(get_cache_data, None)
+        self.assertIsNotNone(get_cache_data)
         self.assertEqual(get_cache_data.content, content.encode())
         # different QUERY_STRING, cache must be empty
         request = self.factory.get(self.path, {'foo': 'bar', 'somethingelse': 'true'})
         request._cache_update_cache = True
         get_cache_data = FetchFromCacheMiddleware().process_request(request)
-        self.assertEqual(get_cache_data, None)
+        self.assertIsNone(get_cache_data)
 
         # i18n tests
         en_message = "Hello world!"
@@ -1684,7 +1684,7 @@ class CacheI18nTest(TestCase):
         set_cache(request, 'en', en_message)
         get_cache_data = FetchFromCacheMiddleware().process_request(request)
         # Check that we can recover the cache
-        self.assertNotEqual(get_cache_data, None)
+        self.assertIsNotNone(get_cache_data)
         self.assertEqual(get_cache_data.content, en_message.encode())
         # Check that we use etags
         self.assertTrue(get_cache_data.has_header('ETag'))
@@ -1818,7 +1818,7 @@ class CacheMiddlewareTest(TestCase):
 
         # Put the request through the request middleware
         result = middleware.process_request(request)
-        self.assertEqual(result, None)
+        self.assertIsNone(result)
 
         response = hello_world_view(request, '1')
 
@@ -1827,16 +1827,16 @@ class CacheMiddlewareTest(TestCase):
 
         # Repeating the request should result in a cache hit
         result = middleware.process_request(request)
-        self.assertNotEqual(result, None)
+        self.assertIsNotNone(result)
         self.assertEqual(result.content, b'Hello World 1')
 
         # The same request through a different middleware won't hit
         result = prefix_middleware.process_request(request)
-        self.assertEqual(result, None)
+        self.assertIsNone(result)
 
         # The same request with a timeout _will_ hit
         result = timeout_middleware.process_request(request)
-        self.assertNotEqual(result, None)
+        self.assertIsNotNone(result)
         self.assertEqual(result.content, b'Hello World 1')
 
     def test_view_decorator(self):
@@ -1989,7 +1989,7 @@ class TestWithTemplateResponse(TestCase):
         response = TemplateResponse(HttpResponse(), Template("This is a test"))
         key_prefix = 'localprefix'
         # Expect None if no headers have been set yet.
-        self.assertEqual(get_cache_key(request), None)
+        self.assertIsNone(get_cache_key(request))
         # Set headers to an empty list.
         learn_cache_key(request, response)
 
@@ -2010,7 +2010,7 @@ class TestWithTemplateResponse(TestCase):
         request = self.factory.get(self.path, {'test': 1})
         response = TemplateResponse(HttpResponse(), Template("This is a test"))
         # Expect None if no headers have been set yet.
-        self.assertEqual(get_cache_key(request), None)
+        self.assertIsNone(get_cache_key(request))
         # Set headers to an empty list.
         learn_cache_key(request, response)
         # Verify that the querystring is taken into account.