ActiveSupport::Cache, fix race conditions on test/cache - part IV

Author: esparta

activesupport/test/cache/behaviors/failure_raising_behavior.rb

@@ -2,109 +2,130 @@
 
 module FailureRaisingBehavior
   def test_fetch_read_failure_raises
-    @cache.write("foo", "bar")
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
 
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.fetch("foo")
+        cache.fetch(key)
       end
     end
   end
 
   def test_fetch_with_block_read_failure_raises
-    @cache.write("foo", "bar")
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.write(key, value)
 
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.fetch("foo") { "1" }
+        cache.fetch(key) { SecureRandom.alphanumeric }
       end
     end
 
-    assert_equal "bar", @cache.read("foo")
+    assert_equal value, @cache.read(key)
   end
 
   def test_read_failure_raises
-    @cache.write("foo", "bar")
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
 
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.read("foo")
+        cache.read(key)
       end
     end
   end
 
   def test_read_multi_failure_raises
-    @cache.write_multi("foo" => "bar", "baz" => "quux")
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write_multi(
+      key => SecureRandom.alphanumeric,
+      other_key => SecureRandom.alphanumeric
+    )
 
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.read_multi("foo", "baz")
+        cache.read_multi(key, other_key)
       end
     end
   end
 
   def test_write_failure_raises
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.write("foo", "bar")
+        cache.write(SecureRandom.uuid, SecureRandom.alphanumeric)
       end
     end
   end
 
   def test_write_multi_failure_raises
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.write_multi("foo" => "bar", "baz" => "quux")
+        cache.write_multi(
+          SecureRandom.uuid => SecureRandom.alphanumeric,
+          SecureRandom.uuid => SecureRandom.alphanumeric
+        )
       end
     end
   end
 
   def test_fetch_multi_failure_raises
-    @cache.write_multi("foo" => "bar", "baz" => "quux")
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write_multi(
+      key => SecureRandom.alphanumeric,
+      other_key => SecureRandom.alphanumeric
+    )
 
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.fetch_multi("foo", "baz") { |k| "unavailable" }
+        cache.fetch_multi(key, other_key) { |k| "unavailable" }
       end
     end
   end
 
   def test_delete_failure_raises
-    @cache.write("foo", "bar")
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
 
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.delete("foo")
+        cache.delete(key)
       end
     end
   end
 
   def test_exist_failure_raises
-    @cache.write("foo", "bar")
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
 
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.exist?("foo")
+        cache.exist?(key)
       end
     end
   end
 
   def test_increment_failure_raises
-    @cache.write("foo", 1, raw: true)
+    key = SecureRandom.uuid
+    @cache.write(key, 1, raw: true)
 
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.increment("foo")
+        cache.increment(key)
       end
     end
   end
 
   def test_decrement_failure_raises
-    @cache.write("foo", 1, raw: true)
+    key = SecureRandom.uuid
+    @cache.write(key, 1, raw: true)
 
     assert_raise Redis::BaseError do
       emulating_unavailability do |cache|
-        cache.decrement("foo")
+        cache.decrement(key)
       end
     end
   end

activesupport/test/cache/behaviors/failure_safety_behavior.rb

@@ -2,96 +2,119 @@
 
 module FailureSafetyBehavior
   def test_fetch_read_failure_returns_nil
-    @cache.write("foo", "bar")
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
 
     emulating_unavailability do |cache|
-      assert_nil cache.fetch("foo")
+      assert_nil cache.fetch(key)
     end
   end
 
   def test_fetch_read_failure_does_not_attempt_to_write
-    @cache.write("foo", "bar")
+    key = SecureRandom.uuid
+    value = SecureRandom.alphanumeric
+    @cache.write(key, value)
 
     emulating_unavailability do |cache|
-      val = cache.fetch("foo") { "1" }
+      val = cache.fetch(key) { "1" }
 
       ##
       # Though the `write` part of fetch fails for the same reason
       # `read` will, the block result is still executed and returned.
       assert_equal "1", val
     end
 
-    assert_equal "bar", @cache.read("foo")
+    assert_equal value, @cache.read(key)
   end
 
   def test_read_failure_returns_nil
-    @cache.write("foo", "bar")
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
 
     emulating_unavailability do |cache|
-      assert_nil cache.read("foo")
+      assert_nil cache.read(key)
     end
   end
 
   def test_read_multi_failure_returns_empty_hash
-    @cache.write_multi("foo" => "bar", "baz" => "quux")
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write_multi(
+      key => SecureRandom.alphanumeric,
+      other_key => SecureRandom.alphanumeric
+    )
 
     emulating_unavailability do |cache|
-      assert_equal Hash.new, cache.read_multi("foo", "baz")
+      assert_equal Hash.new, cache.read_multi(key, other_key)
     end
   end
 
   def test_write_failure_returns_false
+    key = SecureRandom.uuid
     emulating_unavailability do |cache|
-      assert_equal false, cache.write("foo", "bar")
+      assert_equal false, cache.write(key, SecureRandom.alphanumeric)
     end
   end
 
   def test_write_multi_failure_not_raises
     emulating_unavailability do |cache|
       assert_nothing_raised do
-        cache.write_multi("foo" => "bar", "baz" => "quux")
+        cache.write_multi(
+          SecureRandom.uuid => SecureRandom.alphanumeric,
+          SecureRandom.uuid => SecureRandom.alphanumeric
+        )
       end
     end
   end
 
   def test_fetch_multi_failure_returns_fallback_results
-    @cache.write_multi("foo" => "bar", "baz" => "quux")
+    key = SecureRandom.uuid
+    other_key = SecureRandom.uuid
+    @cache.write_multi(
+      key => SecureRandom.alphanumeric,
+      other_key => SecureRandom.alphanumeric
+    )
+
 
     emulating_unavailability do |cache|
-      fetched = cache.fetch_multi("foo", "baz") { |k| "unavailable" }
-      assert_equal Hash["foo" => "unavailable", "baz" => "unavailable"], fetched
+      fetched = cache.fetch_multi(key, other_key) { |k| "unavailable" }
+      assert_equal Hash[key => "unavailable", other_key => "unavailable"], fetched
     end
   end
 
   def test_delete_failure_returns_false
-    @cache.write("foo", "bar")
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
 
     emulating_unavailability do |cache|
-      assert_equal false, cache.delete("foo")
+      assert_equal false, cache.delete(key)
     end
   end
 
   def test_exist_failure_returns_false
-    @cache.write("foo", "bar")
+    key = SecureRandom.uuid
+    @cache.write(key, SecureRandom.alphanumeric)
 
     emulating_unavailability do |cache|
-      assert_not cache.exist?("foo")
+      assert_not cache.exist?(key)
     end
   end
 
   def test_increment_failure_returns_nil
-    @cache.write("foo", 1, raw: true)
+    key = SecureRandom.uuid
+    @cache.write(key, 1, raw: true)
 
     emulating_unavailability do |cache|
-      assert_nil cache.increment("foo")
+      assert_nil cache.increment(key)
     end
   end
 
   def test_decrement_failure_returns_nil
-    @cache.write("foo", 1, raw: true)
+    key = SecureRandom.uuid
+    @cache.write(key, 1, raw: true)
 
     emulating_unavailability do |cache|
-      assert_nil cache.decrement("foo")
+      assert_nil cache.decrement(key)
     end
   end