rails-brotli-cache 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16016a858334a3110d884e44bf6ce43fce75ac926c75973980f189a1477152b3
-  data.tar.gz: 58756fbc6b6da6bde9144f07352302814d638664b567ad9f51ad069073ac0b35
+  metadata.gz: 44c290253b45a487daecc85b45026bd7d3f140644095c7f15cfb67dcee1299b8
+  data.tar.gz: d37323f26dda367401403714eb094dfd6a0e3274b7d88cb81eb2d5380ce91979
 SHA512:
-  metadata.gz: 7276bf3a52a7861fc80c3be8772c190bbc153c26b26f88c152bce44083aae5cfb294b6720d23f40a0f6766905b6b17431d7c1295781604224af9f6738741a68a
-  data.tar.gz: 4c784d5e0ce3fbe2c7242d875b4be25b87b2984148e54ab981d47069613d165b0065e57b0336f933e4bb7206453eb95cb66870dc2eb37d7b2bba005b52bf4e9f
+  metadata.gz: 537fe80385fbc5f8d339b56f789aaeefc45e2589456e2fb522afdcb3656af6254951654a0524b5136ad3cb25fb23c092ea6bc027377c39ed9f52645886a94fc0
+  data.tar.gz: a6057e3a65505003ee849e9f0a38a12963a78468c32275ca0e1d70ead490ddba7663d2a1d65b4359ca7fb626b27e15fc8552d77d9d35c353bbdf77f933fdb277

data/README.md

@@ -1,78 +1,104 @@
 # Rails Brotli Cache [![Gem Version](https://badge.fury.io/rb/rails-brotli-cache.svg)](https://badge.fury.io/rb/rails-brotli-cache) [![CircleCI](https://circleci.com/gh/pawurb/rails-brotli-cache.svg?style=svg)](https://circleci.com/gh/pawurb/rails-brotli-cache)
 
-This gem enables support for compressing Ruby on Rails cache entries using the [Brotli compression algorithm](https://github.com/google/brotli). Brotli is a modern compression algorithm developed by Google that provides superior compression ratios and performance compared to the default Gzip algorithm.
+This gem enables support for compressing Ruby on Rails cache entries using the [Brotli compression algorithm](https://github.com/google/brotli). `RailsBrotliCache` offers better compression and faster performance compared to the default `Rails.cache` regardless of the underlying data store.
 
 **The gem is currently in an early stage of development. Ideas on how to improve it and PRs are welcome.**
 
 ## Benchmarks
 
-Brotli offers a better compression and faster performance.
+Brotli cache works as a proxy layer wrapping the underlying cache data store.
+
+```ruby
+redis_cache = ActiveSupport::Cache::RedisCacheStore.new
+brotli_redis_cache = RailsBrotliCache::Store.new(redis_cache)
+```
 
 **~25%** better compression of a sample JSON object:
 
 ```ruby
-json = File.read("sample.json") # sample 565kb JSON text
-json.size # => 562033
-Rails.cache.write("json", json)
-RailsBrotliCache.write("json", json)
+json = File.read("sample.json") # sample 435kb JSON text
+json.size # => 435662
+redis_cache.write("json", json)
+brotli_redis_cache.write("json", json)
 
 ## Check the size of cache entry stored in Redis
-$redis.get("json").size # => 41697
-$redis.get("br-json").size # => 31601
+$redis.get("json").size # => 31698
+$redis.get("br-json").size # => 24058
 ```
 
 **~20%** better compression of a sample ActiveRecord objects array:
 
 ```ruby
 users = User.limit(100).to_a # 100 ActiveRecord objects
-Rails.cache.write("users", users)
-RailsBrotliCache.write("users", users)
+redis_cache.write("users", users)
+brotli_redis_cache.write("users", users)
 $redis.get("users").size # => 12331
 $redis.get("br-users").size # => 10299
 ```
 
-
 **~25%** faster performance for reading/writing a larger JSON file:
 
 ```ruby
-json = File.read("sample.json") # sample 565kb JSON text
+json = File.read("sample.json") # sample ~1mb JSON text
 
 Benchmark.bm do |x|
-  x.report("Rails.cache") do
-    1000.times do
-      Rails.cache.write("test", json)
-      Rails.cache.read("test")
+  x.report("redis_cache") do
+    100.times do
+      redis_cache.write("test", json)
+      redis_cache.read("test")
     end
   end
 
-  x.report("RailsBrotliCache") do
-    1000.times do
-      RailsBrotliCache.write("test", json)
-      RailsBrotliCache.read("test")
+  x.report("brotli_redis_cache") do
+    100.times do
+      brotli_redis_cache.write("test", json)
+      brotli_redis_cache.read("test")
     end
   end
+
+  # ...
 end
 
-# user     system      total        real
-# Rails.cache  5.177678   0.216435   5.394113 (  8.296072)
-# RailsBrotliCache  3.513312   0.323601   3.836913 (  6.114179)
+# memory_cache  2.081221   0.051615   2.132836 (  2.132877)
+# brotli_memory_cache  1.134411   0.032996   1.167407 (  1.167418)
+# redis_cache  1.782225   0.049936   1.832161 (  2.523317)
+# brotli_redis_cache  1.218365   0.051084   1.269449 (  1.850894)
+# memcached_cache  1.766268   0.045351   1.811619 (  2.504233)
+# brotli_memcached_cache  1.194646   0.051750   1.246396 (  1.752982)
+```
+
+Regardless of the underlying data store, Brotli cache offers between 20%-40% performance improvment.
+
+You can run the benchmarks yourself by executing:
+
+```ruby
+cp docker-compose.yml.sample docker-compose.yml
+docker compose up -d
+cd benchmarks
+bundle install
+ruby main.rb
 ```
 
-## API
+## Configuration
 
-`RailsBrotliCache` module exposes methods that are compatible with the default `Rails.cache`. Values are stored in the underlying `Rails.cache` store but precompressed with Brotli algorithm.
+Gem works as a drop-in replacement for a standard Rails cache store. Here's how you can configure it with different store types:
 
-You can use it just like the default `Rails.cache` API:
+```ruby
+config.cache_store = RailsBrotliCache::Store.new(
+  ActiveSupport::Cache::RedisCacheStore.new(redis: $redis)
+)
+```
 
 ```ruby
-RailsBrotliCache.read("test-key") # => nil
-RailsBrotliCache.fetch("test-key") { 123 } # => 123
-RailsBrotliCache.delete("test-key")
-RailsBrotliCache.read("test-key") # => nil
-RailsBrotliCache.write("test-key", 123, expires_in: 5.seconds)
-sleep 6
-RailsBrotliCache.read("test-key") # => nil
+config.cache_store = RailsBrotliCache::Store.new(
+  ActiveSupport::Cache::MemoryStore.new
+)
+```
 
+```ruby
+config.cache_store = RailsBrotliCache::Store.new(
+  ActiveSupport::Cache::MemCacheStore.new("localhost:11211")
+)
 ```
 
 Gem appends `br-` to the cache key names to prevent conflicts with previously saved cache entries. You can disable this behaviour by adding the following initializer file:
@@ -80,7 +106,7 @@ Gem appends `br-` to the cache key names to prevent conflicts with previously sa
 `app/config/initializers/rails-brotli-cache.rb`
 
 ```ruby
-RailsBrotliCache.disable_prefix!
+Rails.cache.disable_prefix!
 ```
 
 ## Testing

data/Rakefile

@@ -7,5 +7,5 @@ task default: :spec
 
 desc 'Test all cache_stores'
 task :test_all do
-  system("TEST_CACHE_STORE=redis_cache_store bundle exec rspec spec/ && TEST_CACHE_STORE=mem_cache_store bundle exec rspec spec/ && bundle exec rspec spec/")
+  system("RAILS_CACHE_STORE=redis_cache_store bundle exec rspec spec/ && RAILS_CACHE_STORE=brotli_cache_store bundle exec rspec spec/ && bundle exec rspec spec/")
 end

data/benchmarks/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'rails-brotli-cache'

data/benchmarks/main.rb

@@ -0,0 +1,69 @@
+require 'rails'
+require 'net/http'
+require 'rails-brotli-cache'
+
+memory_cache = ActiveSupport::Cache::MemoryStore.new(compress: true) # memory store does not use compression by default
+brotli_memory_cache = RailsBrotliCache::Store.new(memory_cache)
+redis_cache = ActiveSupport::Cache::RedisCacheStore.new
+brotli_redis_cache = RailsBrotliCache::Store.new(redis_cache)
+memcached_cache = ActiveSupport::Cache::MemCacheStore.new
+brotli_memcached_cache = RailsBrotliCache::Store.new(memcached_cache)
+
+json_uri = URI("https://raw.githubusercontent.com/pawurb/rails-brotli-cache/main/spec/fixtures/sample.json")
+json = Net::HTTP.get(json_uri)
+
+puts "Uncompressed JSON size: #{json.size}"
+redis_cache.write("gz-json", json)
+gzip_json_size = redis_cache.redis.get("gz-json").size
+puts "Gzip JSON size: #{gzip_json_size}"
+brotli_redis_cache.write("json", json)
+br_json_size = redis_cache.redis.get("br-json").size
+puts "Brotli JSON size: #{br_json_size}"
+puts "~#{((gzip_json_size - br_json_size).to_f / gzip_json_size.to_f * 100).round}% improvment"
+puts ""
+
+iterations = 100
+
+Benchmark.bm do |x|
+  x.report("memory_cache") do
+    iterations.times do
+      memory_cache.write("test", json)
+      memory_cache.read("test")
+    end
+  end
+
+  x.report("brotli_memory_cache") do
+    iterations.times do
+      brotli_memory_cache.write("test", json)
+      brotli_memory_cache.read("test")
+    end
+  end
+
+  x.report("redis_cache") do
+    iterations.times do
+      redis_cache.write("test", json)
+      redis_cache.read("test")
+    end
+  end
+
+  x.report("brotli_redis_cache") do
+    iterations.times do
+      brotli_redis_cache.write("test", json)
+      brotli_redis_cache.read("test")
+    end
+  end
+
+  x.report("memcached_cache") do
+    iterations.times do
+      memcached_cache.write("test", json)
+      memcached_cache.read("test")
+    end
+  end
+
+  x.report("brotli_memcached_cache") do
+    iterations.times do
+      brotli_memcached_cache.write("test", json)
+      brotli_memcached_cache.read("test")
+    end
+  end
+end

data/lib/rails-brotli-cache/store.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'active_support/cache'
+require 'brotli'
+
+module RailsBrotliCache
+  class Store < ::ActiveSupport::Cache::Store
+    COMPRESS_THRESHOLD = ENV.fetch("BR_CACHE_COMPRESS_THRESHOLD", 1).to_f * 1024.0
+    COMPRESS_QUALITY = ENV.fetch("BR_CACHE_COMPRESS_QUALITY", 5).to_i
+    MARK_BR_COMPRESSED = "\x02".b
+
+    def initialize(core_store, options = {})
+      @core_store = core_store
+      @prefix = "br-"
+    end
+
+    def fetch(name, options = nil, &block)
+      value = read(name, options)
+
+      if value.present? && !options&.fetch(:force, false) == true
+        return value
+      end
+
+      if block_given?
+        value = block.call
+        write(name, value, options)
+
+        value
+      elsif options && options[:force]
+        raise ArgumentError, "Missing block: Calling `Cache#fetch` with `force: true` requires a block."
+      else
+        read(name, options)
+      end
+    end
+
+    def write(name, value, options = nil)
+      serialized = Marshal.dump(value)
+
+      payload = if serialized.bytesize >= COMPRESS_THRESHOLD
+        MARK_BR_COMPRESSED + ::Brotli.deflate(serialized, quality: COMPRESS_QUALITY)
+      else
+        serialized
+      end
+
+      @core_store.write(
+        cache_key(name),
+        payload,
+        (options || {}).merge(compress: false)
+      )
+    end
+
+    def read(name, options = nil)
+      payload = @core_store.read(
+        cache_key(name),
+        options
+      )
+
+      return nil unless payload.present?
+
+      serialized = if payload.start_with?(MARK_BR_COMPRESSED)
+        ::Brotli.inflate(payload.byteslice(1..-1))
+      else
+        payload
+      end
+
+      Marshal.load(serialized)
+    end
+
+    def delete(name, options = nil)
+      @core_store.delete(cache_key(name), options)
+    end
+
+    def clear(options = nil)
+      @core_store.clear
+    end
+
+    def disable_prefix!
+      @prefix = nil
+    end
+
+    private
+
+    def cache_key(name)
+      "#{@prefix}#{name}"
+    end
+  end
+end

data/lib/rails-brotli-cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsBrotliCache
-  VERSION = "0.1.1"
+  VERSION = "0.2.1"
 end

data/lib/rails-brotli-cache.rb

@@ -1,73 +1,7 @@
 # frozen_string_literal: true
 
-require 'rails-brotli-cache/version'
-require 'brotli'
+require 'rails-brotli-cache/store'
 
 module RailsBrotliCache
-  COMPRESS_THRESHOLD = ENV.fetch("BR_CACHE_COMPRESS_THRESHOLD", 1).to_f * 1024.0
-  COMPRESS_QUALITY = ENV.fetch("BR_CACHE_COMPRESS_QUALITY", 5).to_i
-  MARK_BR_COMPRESSED = "\x02".b
-  @@prefix = "br-"
-
-  def self.fetch(name, options = nil, &block)
-    value = read(name, options)
-    return value if value.present?
-
-    if block_given?
-      value = block.call
-      write(name, value, options)
-
-      value
-    elsif options && options[:force]
-      raise ArgumentError, "Missing block: Calling `Cache#fetch` with `force: true` requires a block."
-    else
-      read(name, options)
-    end
-  end
-
-  def self.write(name, value, options = nil)
-    serialized = Marshal.dump(value)
-
-    payload = if serialized.bytesize >= COMPRESS_THRESHOLD
-      MARK_BR_COMPRESSED + ::Brotli.deflate(serialized, quality: COMPRESS_QUALITY)
-    else
-      serialized
-    end
-
-    Rails.cache.write(
-      cache_key(name),
-      payload,
-      (options || {}).merge(compress: false)
-    )
-  end
-
-  def self.read(name, options = nil)
-    payload = Rails.cache.read(
-      cache_key(name),
-      options
-    )
-
-    return nil unless payload.present?
-
-    serialized = if payload.start_with?(MARK_BR_COMPRESSED)
-      ::Brotli.inflate(payload.byteslice(1..-1))
-    else
-      payload
-    end
-
-    Marshal.load(serialized)
-  end
-
-  def self.delete(name, options = nil)
-    Rails.cache.delete(cache_key(name), options)
-  end
-
-  def self.disable_prefix!
-    @@prefix = nil
-  end
-
-  def self.cache_key(name)
-    "#{@@prefix}#{name}"
-  end
 end
 

data/spec/dummy/config/environments/development.rb

@@ -19,7 +19,7 @@ Rails.application.configure do
 
   # Enable/disable caching. By default caching is disabled.
   # Run rails dev:cache to toggle caching.
-  config.cache_store = (ENV["TEST_CACHE_STORE"] || :memory_store).to_sym
+  config.cache_store = $rails_cache_store
 
   # Print deprecation notices to the Rails logger.
   config.active_support.deprecation = :log

data/spec/rails-brotli-cache/rails_store_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+return unless ENV['RAILS_CACHE_STORE'] == 'brotli_cache_store'
+
+describe RailsBrotliCache do
+  subject(:cache_store) do
+    Rails.cache
+  end
+
+  it "sets the correct Rails.cache store" do
+    expect(Rails.cache.class).to eq RailsBrotliCache::Store
+  end
+
+  describe "#fetch" do
+    it "stores value in the configured Rails.cache with a prefix" do
+      cache_store.fetch("test-key") { 123 }
+      expect(cache_store.read("test-key")).to eq 123
+    end
+
+    it "returns nil for missing entries if block is not provided" do
+      expect(cache_store.fetch("missing-key")).to eq nil
+    end
+
+    it "executes block only once" do
+      counter = 0
+      cache_store.fetch("forced-key") { counter += 1 }
+      cache_store.fetch("forced-key") { counter += 1 }
+      expect(cache_store.read("forced-key")).to eq 1
+    end
+
+    context "{ force: true }" do
+      it "raises an error if block is not provided" do
+        expect {
+          cache_store.fetch("missing-key", force: true)
+        }.to raise_error(ArgumentError)
+      end
+
+      it "always refreshes cached entry if block is provided" do
+        counter = 0
+        cache_store.fetch("forced-key", force: true) { counter += 1 }
+        cache_store.fetch("forced-key", force: true) { counter += 1 }
+        expect(cache_store.read("forced-key")).to eq 2
+      end
+    end
+  end
+
+  describe "#read and #write" do
+    it "reads values stored in Rails cache with a prefix" do
+      expect(cache_store.read("test-key")).to eq nil
+      expect(cache_store.write("test-key", 1234))
+      expect(cache_store.read("test-key")).to eq 1234
+    end
+
+    context "payloads smaller then 1kb" do
+      before do
+        expect(Brotli).not_to receive(:deflate)
+      end
+
+      it "does not apply compression" do
+        cache_store.write("test-key", 123)
+        expect(cache_store.read("test-key")).to eq 123
+      end
+    end
+  end
+
+  describe "#delete" do
+    it "removes the previously stored cache entry" do
+      expect(cache_store.write("test-key", 1234))
+      expect(cache_store.read("test-key")).to eq 1234
+      cache_store.delete("test-key")
+      expect(cache_store.read("test-key")).to eq nil
+    end
+  end
+end

data/spec/rails-brotli-cache/redis_spec.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'redis'
 
-return unless ENV["TEST_CACHE_STORE"] == "redis_cache_store"
-$redis = Redis.new
+return unless ENV['RAILS_CACHE_STORE'] == 'redis_cache_store'
 
 describe RailsBrotliCache do
-  it "sets correct cache store based on ENV variable" do
-    expect(Rails.cache.class).to eq ActiveSupport::Cache::RedisCacheStore
+  subject(:cache_store) do
+    RailsBrotliCache::Store.new(
+      ActiveSupport::Cache::RedisCacheStore.new(redis: $redis)
+    )
   end
 
   describe "#fetch" do
     it "stores value in the configured redis cache store" do
-      RailsBrotliCache.fetch("test-key") { 123 }
+      cache_store.fetch("test-key") { 123 }
       expect($redis.get("br-test-key")).to be_present
     end
   end
@@ -24,18 +24,20 @@ describe RailsBrotliCache do
 
   it "applies more efficient brotli compression" do
     Rails.cache.write("gz-test-key", json)
-    RailsBrotliCache.write("test-key", json)
+    cache_store.write("test-key", json)
     expect($redis.get("gz-test-key").size > $redis.get("br-test-key").size).to eq true
   end
 
-  context "payloads smaller then 1kb" do
-    before do
-      # expect(Brotli).not_to receive(:deflate)
-    end
-
-    it "does not apply compression" do
-      RailsBrotliCache.write("test-key", 123)
-      expect(RailsBrotliCache.read("test-key")).to eq 123
+  describe "disable_prefix!" do
+    it "saves brotli cache entries without `br-` prefix" do
+      cache_store.fetch("test-key") { 123 }
+      expect($redis.get("test-key")).to eq nil
+      expect($redis.get("br-test-key")).to be_present
+      cache_store.disable_prefix!
+      cache_store.fetch("test-key-2") { 123 }
+      expect($redis.get("br-test-key-2")).to eq nil
+      expect($redis.get("test-key-2")).to be_present
+      cache_store.instance_variable_set(:@prefix, "br-")
     end
   end
 end

data/spec/rails-brotli-cache/store_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RailsBrotliCache do
+  subject(:cache_store) do
+    RailsBrotliCache::Store.new(ActiveSupport::Cache::MemoryStore.new)
+  end
+
+  describe "#fetch" do
+    it "stores value in the configured Rails.cache with a prefix" do
+      cache_store.fetch("test-key") { 123 }
+      expect(cache_store.read("test-key")).to eq 123
+    end
+
+    it "returns nil for missing entries if block is not provided" do
+      expect(cache_store.fetch("missing-key")).to eq nil
+    end
+
+    it "executes block only once" do
+      counter = 0
+      cache_store.fetch("forced-key") { counter += 1 }
+      cache_store.fetch("forced-key") { counter += 1 }
+      expect(cache_store.read("forced-key")).to eq 1
+    end
+
+    context "{ force: true }" do
+      it "raises an error if block is not provided" do
+        expect {
+          cache_store.fetch("missing-key", force: true)
+        }.to raise_error(ArgumentError)
+      end
+
+      it "always refreshes cached entry if block is provided" do
+        counter = 0
+        cache_store.fetch("forced-key", force: true) { counter += 1 }
+        cache_store.fetch("forced-key", force: true) { counter += 1 }
+        expect(cache_store.read("forced-key")).to eq 2
+      end
+    end
+  end
+
+  describe "#read and #write" do
+    it "reads values stored in Rails cache with a prefix" do
+      expect(cache_store.read("test-key")).to eq nil
+      expect(cache_store.write("test-key", 1234))
+      expect(cache_store.read("test-key")).to eq 1234
+    end
+
+    context "payloads smaller then 1kb" do
+      before do
+        expect(Brotli).not_to receive(:deflate)
+      end
+
+      it "does not apply compression" do
+        cache_store.write("test-key", 123)
+        expect(cache_store.read("test-key")).to eq 123
+      end
+    end
+  end
+
+  describe "#delete" do
+    it "removes the previously stored cache entry" do
+      expect(cache_store.write("test-key", 1234))
+      expect(cache_store.read("test-key")).to eq 1234
+      cache_store.delete("test-key")
+      expect(cache_store.read("test-key")).to eq nil
+    end
+  end
+
+  describe "disable_prefix!" do
+    it "saves brotli cache entries without `br-` prefix" do
+      cache_store.disable_prefix!
+      cache_store.fetch("test-key") { 123 }
+      cache_store.instance_variable_set(:@prefix, "br-")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,8 +1,19 @@
 require 'rubygems'
 require 'bundler/setup'
 require 'rails'
+require 'redis'
 
 require_relative '../lib/rails-brotli-cache'
+
+$redis = Redis.new
+$rails_cache_store = if ENV['RAILS_CACHE_STORE'] == 'redis_cache_store'
+  ActiveSupport::Cache::RedisCacheStore.new(redis: $redis)
+elsif ENV['RAILS_CACHE_STORE'] == 'brotli_cache_store'
+  RailsBrotliCache::Store.new(ActiveSupport::Cache::MemoryStore.new)
+else
+  ActiveSupport::Cache::MemoryStore.new
+end
+
 require_relative '../spec/dummy/config/environment'
 ENV['RAILS_ROOT'] ||= "#{File.dirname(__FILE__)}../../../spec/dummy"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-brotli-cache
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - pawurb
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-17 00:00:00.000000000 Z
+date: 2023-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -108,8 +108,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/Gemfile
+- benchmarks/main.rb
 - docker-compose.yml.sample
 - lib/rails-brotli-cache.rb
+- lib/rails-brotli-cache/store.rb
 - lib/rails-brotli-cache/version.rb
 - rails-brotli-cache.gemspec
 - spec/dummy/Gemfile
@@ -155,8 +158,9 @@ files:
 - spec/dummy/public/robots.txt
 - spec/dummy/vendor/.keep
 - spec/fixtures/sample.json
-- spec/rails-brotli-cache/common_spec.rb
+- spec/rails-brotli-cache/rails_store_spec.rb
 - spec/rails-brotli-cache/redis_spec.rb
+- spec/rails-brotli-cache/store_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/pawurb/rails-brotli-cache
 licenses:
@@ -225,6 +229,7 @@ test_files:
 - spec/dummy/public/robots.txt
 - spec/dummy/vendor/.keep
 - spec/fixtures/sample.json
-- spec/rails-brotli-cache/common_spec.rb
+- spec/rails-brotli-cache/rails_store_spec.rb
 - spec/rails-brotli-cache/redis_spec.rb
+- spec/rails-brotli-cache/store_spec.rb
 - spec/spec_helper.rb

data/spec/rails-brotli-cache/common_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe RailsBrotliCache do
-  context "without prepending Rails.cache" do
-    describe "#fetch" do
-      it "stores value in the configured Rails.cache with a prefix" do
-        RailsBrotliCache.fetch("test-key") { 123 }
-        expect(RailsBrotliCache.read("test-key")).to eq 123
-        expect(Rails.cache.read("br-test-key")).to be_present
-      end
-
-      it "returns nil for missing entries if block is not provided" do
-        expect(RailsBrotliCache.fetch("missing-key")).to eq nil
-      end
-
-      context "{ force: true }" do
-        it "raises an error if block is not provided" do
-          expect {
-            RailsBrotliCache.fetch("missing-key", force: true)
-          }.to raise_error(ArgumentError)
-        end
-
-        it "always refreshes cached entry if block is provided" do
-
-        end
-      end
-    end
-
-    describe "#read and #write" do
-      it "reads values stored in Rails cache with a prefix" do
-        expect(RailsBrotliCache.read("test-key")).to eq nil
-        expect(RailsBrotliCache.write("test-key", 1234))
-        expect(RailsBrotliCache.read("test-key")).to eq 1234
-      end
-    end
-
-    describe "#delete" do
-      it "removes the previously stored cache entry" do
-        expect(RailsBrotliCache.write("test-key", 1234))
-        expect(RailsBrotliCache.read("test-key")).to eq 1234
-        RailsBrotliCache.delete("test-key")
-        expect(RailsBrotliCache.read("test-key")).to eq nil
-      end
-    end
-
-    describe "disable_prefix!" do
-      it "saves brotli cache entries without `br-` prefix" do
-        RailsBrotliCache.disable_prefix!
-        RailsBrotliCache.fetch("test-key") { 123 }
-        expect(Rails.cache.read("br-test-key")).to eq nil
-        expect(Rails.cache.read("test-key")).to be_present
-        RailsBrotliCache.class_variable_set(:@@prefix, "br-")
-      end
-    end
-  end
-end