Merge pull request rails#48450 from jonathanhefner/cache-compression-tests

Refactor cache compression tests

Author: jonathanhefner

activesupport/test/cache/behaviors.rb

@@ -7,6 +7,7 @@
 require_relative "behaviors/cache_store_behavior"
 require_relative "behaviors/cache_store_version_behavior"
 require_relative "behaviors/cache_store_coder_behavior"
+require_relative "behaviors/cache_store_compression_behavior"
 require_relative "behaviors/cache_store_format_version_behavior"
 require_relative "behaviors/connection_pool_behavior"
 require_relative "behaviors/encoded_key_cache_behavior"

activesupport/test/cache/behaviors/cache_store_behavior.rb

@@ -266,105 +266,6 @@ def test_fetch_multi_uses_write_multi_entries_store_provider_interface
     end
   end
 
-  # Use strings that are guaranteed to compress well, so we can easily tell if
-  # the compression kicked in or not.
-  SMALL_STRING = "0" * 100
-  LARGE_STRING = "0" * 2.kilobytes
-
-  SMALL_OBJECT = { data: SMALL_STRING }
-  LARGE_OBJECT = { data: LARGE_STRING }
-
-  def test_nil_with_default_compression_settings
-    assert_uncompressed(nil)
-  end
-
-  def test_nil_with_compress_true
-    assert_uncompressed(nil, compress: true)
-  end
-
-  def test_nil_with_compress_false
-    assert_uncompressed(nil, compress: false)
-  end
-
-  def test_nil_with_compress_low_compress_threshold
-    assert_uncompressed(nil, compress: true, compress_threshold: 20)
-  end
-
-  def test_small_string_with_default_compression_settings
-    assert_uncompressed(SMALL_STRING)
-  end
-
-  def test_small_string_with_compress_true
-    assert_uncompressed(SMALL_STRING, compress: true)
-  end
-
-  def test_small_string_with_compress_false
-    assert_uncompressed(SMALL_STRING, compress: false)
-  end
-
-  def test_small_string_with_low_compress_threshold
-    assert_compressed(SMALL_STRING, compress: true, compress_threshold: 1)
-  end
-
-  def test_small_object_with_default_compression_settings
-    assert_uncompressed(SMALL_OBJECT)
-  end
-
-  def test_small_object_with_compress_true
-    assert_uncompressed(SMALL_OBJECT, compress: true)
-  end
-
-  def test_small_object_with_compress_false
-    assert_uncompressed(SMALL_OBJECT, compress: false)
-  end
-
-  def test_small_object_with_low_compress_threshold
-    assert_compressed(SMALL_OBJECT, compress: true, compress_threshold: 1)
-  end
-
-  def test_large_string_with_compress_true
-    assert_compressed(LARGE_STRING, compress: true)
-  end
-
-  def test_large_string_with_compress_false
-    assert_uncompressed(LARGE_STRING, compress: false)
-  end
-
-  def test_large_string_with_high_compress_threshold
-    assert_uncompressed(LARGE_STRING, compress: true, compress_threshold: 1.megabyte)
-  end
-
-  def test_large_object_with_compress_true
-    assert_compressed(LARGE_OBJECT, compress: true)
-  end
-
-  def test_large_object_with_compress_false
-    assert_uncompressed(LARGE_OBJECT, compress: false)
-  end
-
-  def test_large_object_with_high_compress_threshold
-    assert_uncompressed(LARGE_OBJECT, compress: true, compress_threshold: 1.megabyte)
-  end
-
-  def test_incompressible_data
-    assert_uncompressed(nil, compress: true, compress_threshold: 30)
-    assert_uncompressed(true, compress: true, compress_threshold: 30)
-    assert_uncompressed(false, compress: true, compress_threshold: 30)
-    assert_uncompressed(0, compress: true, compress_threshold: 30)
-    assert_uncompressed(1.2345, compress: true, compress_threshold: 30)
-    assert_uncompressed("", compress: true, compress_threshold: 30)
-
-    incompressible = nil
-
-    # generate an incompressible string
-    loop do
-      incompressible = Random.bytes(1.kilobyte)
-      break if incompressible.bytesize < Zlib::Deflate.deflate(incompressible).bytesize
-    end
-
-    assert_uncompressed(incompressible, compress: true, compress_threshold: 1)
-  end
-
   def test_cache_key
     key = SecureRandom.uuid
     klass = Class.new do
@@ -801,47 +702,6 @@ def test_cache_miss_instrumentation
   end
 
   private
-    def assert_compressed(value, **options)
-      assert_compression(true, value, **options)
-    end
-
-    def assert_uncompressed(value, **options)
-      assert_compression(false, value, **options)
-    end
-
-    def assert_compression(should_compress, value, **options)
-      actual = "actual" + SecureRandom.uuid
-      uncompressed = "uncompressed" + SecureRandom.uuid
-
-      freeze_time do
-        @cache.write(actual, value, options)
-        @cache.write(uncompressed, value, options.merge(compress: false))
-      end
-
-      if value.nil?
-        assert_nil @cache.read(actual)
-        assert_nil @cache.read(uncompressed)
-      else
-        assert_equal value, @cache.read(actual)
-        assert_equal value, @cache.read(uncompressed)
-      end
-
-      actual_entry = @cache.send(:read_entry, @cache.send(:normalize_key, actual, {}), **{})
-      uncompressed_entry = @cache.send(:read_entry, @cache.send(:normalize_key, uncompressed, {}), **{})
-
-      actual_payload = @cache.send(:serialize_entry, actual_entry, **@cache.send(:merged_options, options))
-      uncompressed_payload = @cache.send(:serialize_entry, uncompressed_entry, compress: false)
-
-      actual_size = actual_payload.bytesize
-      uncompressed_size = uncompressed_payload.bytesize
-
-      if should_compress
-        assert_operator actual_size, :<, uncompressed_size, "value should be compressed"
-      else
-        assert_equal uncompressed_size, actual_size, "value should not be compressed"
-      end
-    end
-
     def with_raise_on_invalid_cache_expiration_time(new_value, &block)
       old_value = ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time
       ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time = new_value

activesupport/test/cache/behaviors/cache_store_compression_behavior.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/numeric/bytes"
+
+module CacheStoreCompressionBehavior
+  extend ActiveSupport::Concern
+
+  included do
+    test "compression by default" do
+      @cache = lookup_store
+
+      assert_uncompressed SMALL_STRING
+      assert_uncompressed SMALL_OBJECT
+      if compression_always_disabled_by_default?
+        assert_uncompressed LARGE_STRING
+        assert_uncompressed LARGE_OBJECT
+      else
+        assert_compressed LARGE_STRING
+        assert_compressed LARGE_OBJECT
+      end
+    end
+
+    test "compression can be disabled" do
+      @cache = lookup_store(compress: false)
+
+      assert_uncompressed SMALL_STRING
+      assert_uncompressed SMALL_OBJECT
+      assert_uncompressed LARGE_STRING
+      assert_uncompressed LARGE_OBJECT
+    end
+
+    test ":compress method option overrides initializer option" do
+      @cache = lookup_store(compress: true)
+
+      assert_uncompressed SMALL_STRING, compress: false
+      assert_uncompressed SMALL_OBJECT, compress: false
+      assert_uncompressed LARGE_STRING, compress: false
+      assert_uncompressed LARGE_OBJECT, compress: false
+
+      @cache = lookup_store(compress: false)
+
+      assert_uncompressed SMALL_STRING, compress: true
+      assert_uncompressed SMALL_OBJECT, compress: true
+      assert_compressed LARGE_STRING, compress: true
+      assert_compressed LARGE_OBJECT, compress: true
+    end
+
+    test "low :compress_threshold triggers compression" do
+      @cache = lookup_store(compress: true, compress_threshold: 1)
+
+      assert_compressed SMALL_STRING
+      assert_compressed SMALL_OBJECT
+      assert_compressed LARGE_STRING
+      assert_compressed LARGE_OBJECT
+    end
+
+    test "high :compress_threshold inhibits compression" do
+      @cache = lookup_store(compress: true, compress_threshold: 1.megabyte)
+
+      assert_uncompressed SMALL_STRING
+      assert_uncompressed SMALL_OBJECT
+      assert_uncompressed LARGE_STRING
+      assert_uncompressed LARGE_OBJECT
+    end
+
+    test ":compress_threshold method option overrides initializer option" do
+      @cache = lookup_store(compress: true, compress_threshold: 1)
+
+      assert_uncompressed SMALL_STRING, compress_threshold: 1.megabyte
+      assert_uncompressed SMALL_OBJECT, compress_threshold: 1.megabyte
+      assert_uncompressed LARGE_STRING, compress_threshold: 1.megabyte
+      assert_uncompressed LARGE_OBJECT, compress_threshold: 1.megabyte
+
+      @cache = lookup_store(compress: true, compress_threshold: 1.megabyte)
+
+      assert_compressed SMALL_STRING, compress_threshold: 1
+      assert_compressed SMALL_OBJECT, compress_threshold: 1
+      assert_compressed LARGE_STRING, compress_threshold: 1
+      assert_compressed LARGE_OBJECT, compress_threshold: 1
+    end
+
+    test "compression ignores nil" do
+      assert_uncompressed nil
+      assert_uncompressed nil, compress: true, compress_threshold: 1
+    end
+
+    test "compression ignores incompressible data" do
+      assert_uncompressed "", compress: true, compress_threshold: 1
+      assert_uncompressed [*0..127].pack("C*"), compress: true, compress_threshold: 1
+    end
+  end
+
+  private
+    # Use strings that are guaranteed to compress well, so we can easily tell if
+    # the compression kicked in or not.
+    SMALL_STRING = "0" * 100
+    LARGE_STRING = "0" * 2.kilobytes
+
+    SMALL_OBJECT = { data: SMALL_STRING }
+    LARGE_OBJECT = { data: LARGE_STRING }
+
+    def assert_compressed(value, **options)
+      assert_operator compute_entry_size_reduction(value, **options), :>, 0
+    end
+
+    def assert_uncompressed(value, **options)
+      assert_equal 0, compute_entry_size_reduction(value, **options)
+    end
+
+    def compute_entry_size_reduction(value, **options)
+      entry = ActiveSupport::Cache::Entry.new(value)
+
+      uncompressed = @cache.send(:serialize_entry, entry, **options, compress: false)
+      actual = @cache.send(:serialize_entry, entry, **options)
+
+      uncompressed.bytesize - actual.bytesize
+    end
+
+    def compression_always_disabled_by_default?
+      false
+    end
+end

activesupport/test/cache/stores/file_store_test.rb

@@ -32,6 +32,7 @@ def teardown
   include CacheStoreBehavior
   include CacheStoreVersionBehavior
   include CacheStoreCoderBehavior
+  include CacheStoreCompressionBehavior
   include CacheStoreFormatVersionBehavior
   include CacheDeleteMatchedBehavior
   include CacheIncrementDecrementBehavior

activesupport/test/cache/stores/mem_cache_store_test.rb

@@ -77,6 +77,7 @@ def after_teardown
   include CacheStoreBehavior
   include CacheStoreVersionBehavior
   include CacheStoreCoderBehavior
+  include CacheStoreCompressionBehavior
   include CacheStoreFormatVersionBehavior
   include LocalCacheBehavior
   include CacheIncrementDecrementBehavior
@@ -327,14 +328,6 @@ def test_falls_back_to_localhost_if_no_address_provided_and_memcache_servers_def
     end
   end
 
-  def test_large_string_with_default_compression_settings
-    assert_compressed(LARGE_STRING)
-  end
-
-  def test_large_object_with_default_compression_settings
-    assert_compressed(LARGE_OBJECT)
-  end
-
   def test_can_load_raw_values_from_dalli_store
     key = "test-with-value-the-way-the-dalli-store-did"
 

activesupport/test/cache/stores/memory_store_test.rb

@@ -16,19 +16,12 @@ def lookup_store(options = {})
   include CacheStoreBehavior
   include CacheStoreVersionBehavior
   include CacheStoreCoderBehavior
+  include CacheStoreCompressionBehavior
   include CacheDeleteMatchedBehavior
   include CacheIncrementDecrementBehavior
   include CacheInstrumentationBehavior
   include CacheLoggingBehavior
 
-  def test_large_string_with_default_compression_settings
-    assert_uncompressed(LARGE_STRING)
-  end
-
-  def test_large_object_with_default_compression_settings
-    assert_uncompressed(LARGE_OBJECT)
-  end
-
   def test_increment_preserves_expiry
     @cache = lookup_store
     @cache.write("counter", 1, raw: true, expires_in: 30.seconds)
@@ -58,6 +51,11 @@ def test_cleanup_instrumentation
     assert_equal size, events[0].payload[:size]
     assert_equal @cache.class.name, events[0].payload[:store]
   end
+
+  private
+    def compression_always_disabled_by_default?
+      true
+    end
 end
 
 class MemoryStorePruningTest < ActiveSupport::TestCase

activesupport/test/cache/stores/redis_cache_store_test.rb

@@ -159,6 +159,7 @@ class RedisCacheStoreCommonBehaviorTest < StoreTest
     include CacheStoreBehavior
     include CacheStoreVersionBehavior
     include CacheStoreCoderBehavior
+    include CacheStoreCompressionBehavior
     include CacheStoreFormatVersionBehavior
     include LocalCacheBehavior
     include CacheIncrementDecrementBehavior
@@ -233,14 +234,6 @@ def test_decrement_expires_in
         assert_equal false, @cache.exist?("foo")
       end
     end
-
-    def test_large_string_with_default_compression_settings
-      assert_compressed(LARGE_STRING)
-    end
-
-    def test_large_object_with_default_compression_settings
-      assert_compressed(LARGE_OBJECT)
-    end
   end
 
   class ConnectionPoolBehaviorTest < StoreTest