faraday-http-cache 2.1.0 → 2.4.0

data/lib/faraday/http_cache/strategies.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'faraday/http_cache/strategies/by_url'
+require 'faraday/http_cache/strategies/by_vary'

data/lib/faraday/http_cache.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
+
 require 'faraday'
 
 require 'faraday/http_cache/storage'
 require 'faraday/http_cache/request'
 require 'faraday/http_cache/response'
+require 'faraday/http_cache/strategies'
 
 module Faraday
   # Public: The middleware responsible for caching and serving responses.
-  # The middleware use the provided configuration options to establish a
-  # 'Faraday::HttpCache::Storage' to cache responses retrieved by the stack
+  # The middleware use the provided configuration options to establish on of
+  # 'Faraday::HttpCache::Strategies' to cache responses retrieved by the stack
   # adapter. If a stored response can be served again for a subsequent
   # request, the middleware will return the response instead of issuing a new
   # request to it's server. This middleware should be the last attached handler
@@ -44,7 +46,7 @@ module Faraday
   #     builder.use :http_cache, store: Rails.cache, instrumenter: ActiveSupport::Notifications
   #   end
   class HttpCache < Faraday::Middleware
-    UNSAFE_METHODS = [:post, :put, :delete, :patch].freeze
+    UNSAFE_METHODS = %i[post put delete patch].freeze
 
     ERROR_STATUSES = (400..499).freeze
 
@@ -71,7 +73,7 @@ module Faraday
       :uncacheable,
 
       # The request was cached but need to be revalidated by the server.
-      :must_revalidate,
+      :must_revalidate
     ].freeze
 
     # Public: Initializes a new HttpCache middleware.
@@ -90,7 +92,7 @@ module Faraday
     #   Faraday::HttpCache.new(app, logger: my_logger)
     #
     #   # Initialize the middleware with a logger and Marshal as a serializer
-    #   Faraday:HttpCache.new(app, logger: my_logger, serializer: Marshal)
+    #   Faraday::HttpCache.new(app, logger: my_logger, serializer: Marshal)
     #
     #   # Initialize the middleware with a FileStore at the 'tmp' dir.
     #   store = ActiveSupport::Cache.lookup_store(:file_store, ['tmp'])
@@ -99,14 +101,18 @@ module Faraday
     #   # Initialize the middleware with a MemoryStore and logger
     #   store = ActiveSupport::Cache.lookup_store
     #   Faraday::HttpCache.new(app, store: store, logger: my_logger)
-    def initialize(app, store: nil, serializer: nil, shared_cache: true, instrumenter: nil, instrument_name: EVENT_NAME, logger: nil) # rubocop:disable Metrics/ParameterLists
+    def initialize(app, options = {})
       super(app)
 
-      @logger = logger
-      @shared_cache = shared_cache
-      @instrumenter = instrumenter
-      @instrument_name = instrument_name
-      @storage = Storage.new(store: store, serializer: serializer, logger: logger)
+      options = options.dup
+      @logger = options[:logger]
+      @shared_cache = options.delete(:shared_cache) { true }
+      @instrumenter = options.delete(:instrumenter)
+      @instrument_name = options.delete(:instrument_name) { EVENT_NAME }
+
+      strategy = options.delete(:strategy) { Strategies::ByUrl }
+
+      @strategy = strategy.new(**options)
     end
 
     # Public: Process the request into a duplicate of this instance to
@@ -151,9 +157,6 @@ module Faraday
     # Internal: Gets the request object created from the Faraday env Hash.
     attr_reader :request
 
-    # Internal: Gets the storage instance associated with the middleware.
-    attr_reader :storage
-
     private
 
     # Internal: Should this cache instance act like a "shared cache" according
@@ -182,7 +185,7 @@ module Faraday
     #
     # Returns the 'Faraday::Response' instance to be served.
     def process(env)
-      entry = @storage.read(@request)
+      entry = @strategy.read(@request)
 
       return fetch(env) if entry.nil?
 
@@ -256,20 +259,20 @@ module Faraday
     def store(response)
       if shared_cache? ? response.cacheable_in_shared_cache? : response.cacheable_in_private_cache?
         trace :store
-        @storage.write(@request, response)
+        @strategy.write(@request, response)
       else
         trace :uncacheable
       end
     end
 
     def delete(request, response)
-      headers = %w(Location Content-Location)
+      headers = %w[Location Content-Location]
       headers.each do |header|
         url = response.headers[header]
-        @storage.delete(url) if url
+        @strategy.delete(url) if url
       end
 
-      @storage.delete(request.url)
+      @strategy.delete(request.url)
       trace :delete
     end
 
@@ -297,7 +300,7 @@ module Faraday
 
       {
         status: hash[:status],
-        body: hash[:body],
+        body: hash[:body] || hash[:response_body],
         response_headers: hash[:response_headers]
       }
     end

data/spec/binary_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Faraday::HttpCache do
@@ -10,7 +11,7 @@ describe Faraday::HttpCache do
       stack.adapter adapter.to_sym
     end
   end
-  let(:data) { IO.binread File.expand_path('../support/empty.png', __FILE__) }
+  let(:data) { IO.binread File.expand_path('support/empty.png', __dir__) }
 
   it 'works fine with binary data' do
     expect(client.get('image').body).to eq data

data/spec/cache_control_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Faraday::HttpCache::CacheControl do

data/spec/http_cache_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Faraday::HttpCache do
@@ -36,7 +37,7 @@ describe Faraday::HttpCache do
 
   it 'adds a trace of the actions performed to the env' do
     response = client.post('post')
-    expect(response.env[:http_cache_trace]).to eq([:unacceptable, :delete])
+    expect(response.env[:http_cache_trace]).to eq(%i[unacceptable delete])
   end
 
   describe 'cache invalidation' do
@@ -282,23 +283,13 @@ describe Faraday::HttpCache do
     expect(client.get('must-revalidate').body).to eq('1')
   end
 
-  it 'raises an error when misconfigured' do
-    expect {
-      client = Faraday.new(url: ENV['FARADAY_SERVER']) do |stack|
-        stack.use Faraday::HttpCache, i_have_no_idea: true
-      end
-
-      client.get('get')
-    }.to raise_error(ArgumentError)
-  end
-
   describe 'Configuration options' do
     let(:app) { double('it is an app!') }
 
     it 'uses the options to create a Cache Store' do
       store = double(read: nil, write: nil)
 
-      expect(Faraday::HttpCache::Storage).to receive(:new).with(hash_including(store: store))
+      expect(Faraday::HttpCache::Strategies::ByUrl).to receive(:new).with(hash_including(store: store))
       Faraday::HttpCache.new(app, store: store)
     end
   end

data/spec/instrumentation_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 require 'active_support'
 require 'active_support/notifications'

data/spec/json_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Faraday::HttpCache do

data/spec/request_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Faraday::HttpCache::Request do

data/spec/response_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Faraday::HttpCache::Response do
@@ -228,11 +229,11 @@ describe Faraday::HttpCache::Response do
   describe 'remove age before caching and normalize max-age if non-zero age present' do
     it 'is fresh if the response still has some time to live' do
       headers = {
-          'Age' => 6,
-          'Cache-Control' => 'public, max-age=40',
-          'Date' => (Time.now - 38).httpdate,
-          'Expires' => (Time.now - 37).httpdate,
-          'Last-Modified' => (Time.now - 300).httpdate
+        'Age' => 6,
+        'Cache-Control' => 'public, max-age=40',
+        'Date' => (Time.now - 38).httpdate,
+        'Expires' => (Time.now - 37).httpdate,
+        'Last-Modified' => (Time.now - 300).httpdate
       }
       response = Faraday::HttpCache::Response.new(response_headers: headers)
       expect(response).to be_fresh

data/spec/spec_helper.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
+
 require 'uri'
 require 'socket'
 
 require 'faraday-http-cache'
-require 'faraday_middleware'
 
-# https://github.com/rails/rails/pull/14667
-require 'active_support/per_thread_registry'
+if Gem::Version.new(Faraday::VERSION) < Gem::Version.new('1.0')
+  require 'faraday_middleware'
+elsif ENV['FARADAY_ADAPTER'] == 'em_http'
+  require 'faraday/em_http'
+end
+
+require 'active_support'
 require 'active_support/cache'
 
 require 'support/test_app'

data/spec/storage_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Faraday::HttpCache::Storage do
@@ -15,6 +16,21 @@ describe Faraday::HttpCache::Storage do
   let(:storage) { Faraday::HttpCache::Storage.new(store: cache) }
   subject { storage }
 
+  before do
+    allow(Kernel).to receive(:warn).with(
+      'Deprecated: Faraday::HttpCache::Storage is deprecated and will be removed '\
+      'in the next major release. Use Faraday::HttpCache::Strategies::ByUrl instead.'
+    )
+  end
+
+  it 'creates strategy and warns about deprecation' do
+    expect(Kernel).to receive(:warn).with(
+      'Deprecated: Faraday::HttpCache::Storage is deprecated and will be removed '\
+      'in the next major release. Use Faraday::HttpCache::Strategies::ByUrl instead.'
+    )
+    is_expected.to be_a_kind_of(Faraday::HttpCache::Strategies::ByUrl)
+  end
+
   describe 'Cache configuration' do
     it 'uses a MemoryStore by default' do
       expect(Faraday::HttpCache::MemoryStore).to receive(:new).and_call_original
@@ -43,7 +59,7 @@ describe Faraday::HttpCache::Storage do
       let(:serializer) { JSON }
       it_behaves_like 'A storage with serialization'
 
-      context 'when ASCII characters in response cannot be converted to UTF-8' do
+      context 'when ASCII characters in response cannot be converted to UTF-8', if: Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1') do
         let(:response) do
           body = String.new("\u2665").force_encoding('ASCII-8BIT')
           double(:response, serializable_hash: { 'body' => body })
@@ -111,11 +127,11 @@ describe Faraday::HttpCache::Storage do
   describe 'remove age before caching and normalize max-age if non-zero age present' do
     it 'is fresh if the response still has some time to live' do
       headers = {
-          'Age' => 6,
-          'Cache-Control' => 'public, max-age=40',
-          'Date' => (Time.now - 38).httpdate,
-          'Expires' => (Time.now - 37).httpdate,
-          'Last-Modified' => (Time.now - 300).httpdate
+        'Age' => 6,
+        'Cache-Control' => 'public, max-age=40',
+        'Date' => (Time.now - 38).httpdate,
+        'Expires' => (Time.now - 37).httpdate,
+        'Last-Modified' => (Time.now - 300).httpdate
       }
       response = Faraday::HttpCache::Response.new(response_headers: headers)
       expect(response).to be_fresh
@@ -127,9 +143,10 @@ describe Faraday::HttpCache::Storage do
     end
 
     it 'is fresh until cached and that 1 second elapses then the response is no longer fresh' do
+      current_time = Time.now
       headers = {
-        'Date' => (Time.now - 39).httpdate,
-        'Expires' => (Time.now + 40).httpdate
+        'Date' => (current_time - 39).httpdate,
+        'Expires' => (current_time + 40).httpdate
       }
 
       response = Faraday::HttpCache::Response.new(response_headers: headers)

data/spec/strategies/base_strategy_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Faraday::HttpCache::Strategies::BaseStrategy do
+  subject(:strategy) { described_class.new }
+
+  it 'uses a MemoryStore as a default store' do
+    expect(Faraday::HttpCache::MemoryStore).to receive(:new).and_call_original
+    strategy
+  end
+
+  context 'when the given store is not valid' do
+    let(:store) { double(:wrong_store) }
+    subject(:strategy) { described_class.new(store: store) }
+
+    it 'raises an error' do
+      expect { strategy }.to raise_error(ArgumentError)
+    end
+  end
+
+  it 'raises an error when abstract methods are called' do
+    expect { strategy.write(nil, nil) }.to raise_error(NotImplementedError)
+    expect { strategy.read(nil) }.to raise_error(NotImplementedError)
+    expect { strategy.delete(nil) }.to raise_error(NotImplementedError)
+  end
+end

data/spec/strategies/by_url_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Faraday::HttpCache::Strategies::ByUrl do
+  let(:cache_key) { '6e3b941d0f7572291c777b3e48c04b74124a55d0' }
+  let(:request) do
+    env = { method: :get, url: 'http://test/index' }
+    double(env.merge(serializable_hash: env))
+  end
+
+  let(:response) { double(serializable_hash: { response_headers: {} }) }
+
+  let(:cache) { Faraday::HttpCache::MemoryStore.new }
+
+  let(:strategy) { described_class.new(store: cache) }
+  subject { strategy }
+
+  describe 'Cache configuration' do
+    it 'uses a MemoryStore by default' do
+      expect(Faraday::HttpCache::MemoryStore).to receive(:new).and_call_original
+      described_class.new
+    end
+
+    it 'raises an error when the given store is not valid' do
+      wrong = double
+
+      expect {
+        described_class.new(store: wrong)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe 'storing responses' do
+    shared_examples 'A strategy with serialization' do
+      it 'writes the response object to the underlying cache' do
+        entry = [serializer.dump(request.serializable_hash), serializer.dump(response.serializable_hash)]
+        expect(cache).to receive(:write).with(cache_key, [entry])
+        subject.write(request, response)
+      end
+    end
+
+    context 'with the JSON serializer' do
+      let(:serializer) { JSON }
+      it_behaves_like 'A strategy with serialization'
+
+      context 'when ASCII characters in response cannot be converted to UTF-8', if: Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1') do
+        let(:response) do
+          body = String.new("\u2665").force_encoding('ASCII-8BIT')
+          double(:response, serializable_hash: { 'body' => body })
+        end
+
+        it 'raises and logs a warning' do
+          logger = double(:logger, warn: nil)
+          strategy = described_class.new(logger: logger)
+
+          expect {
+            strategy.write(request, response)
+          }.to raise_error(::Encoding::UndefinedConversionError)
+          expect(logger).to have_received(:warn).with(
+            'Response could not be serialized: "\xE2" from ASCII-8BIT to UTF-8. Try using Marshal to serialize.'
+          )
+        end
+      end
+    end
+
+    context 'with the Marshal serializer' do
+      let(:cache_key) { '337d1e9c6c92423dd1c48a23054139058f97be40' }
+      let(:serializer) { Marshal }
+      let(:strategy) { described_class.new(store: cache, serializer: Marshal) }
+
+      it_behaves_like 'A strategy with serialization'
+    end
+  end
+
+  describe 'reading responses' do
+    let(:strategy) { described_class.new(store: cache, serializer: serializer) }
+
+    shared_examples 'A strategy with serialization' do
+      it 'returns nil if the response is not cached' do
+        expect(subject.read(request)).to be_nil
+      end
+
+      it 'decodes a stored response' do
+        subject.write(request, response)
+
+        expect(subject.read(request)).to be_a(Faraday::HttpCache::Response)
+      end
+    end
+
+    context 'with the JSON serializer' do
+      let(:serializer) { JSON }
+
+      it_behaves_like 'A strategy with serialization'
+    end
+
+    context 'with the Marshal serializer' do
+      let(:serializer) { Marshal }
+
+      it_behaves_like 'A strategy with serialization'
+    end
+  end
+
+  describe 'deleting responses' do
+    it 'removes the entries from the cache of the given URL' do
+      subject.write(request, response)
+      subject.delete(request.url)
+      expect(subject.read(request)).to be_nil
+    end
+  end
+
+  describe 'remove age before caching and normalize max-age if non-zero age present' do
+    it 'is fresh if the response still has some time to live' do
+      headers = {
+        'Age' => 6,
+        'Cache-Control' => 'public, max-age=40',
+        'Date' => (Time.now - 38).httpdate,
+        'Expires' => (Time.now - 37).httpdate,
+        'Last-Modified' => (Time.now - 300).httpdate
+      }
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
+      expect(response).to be_fresh
+      subject.write(request, response)
+
+      cached_response = subject.read(request)
+      expect(cached_response.max_age).to eq(34)
+      expect(cached_response).not_to be_fresh
+    end
+
+    it 'is fresh until cached and that 1 second elapses then the response is no longer fresh' do
+      headers = {
+        'Date' => (Time.now - 39).httpdate,
+        'Expires' => (Time.now + 40).httpdate
+      }
+
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
+      expect(response).to be_fresh
+      subject.write(request, response)
+
+      sleep(1)
+      cached_response = subject.read(request)
+      expect(cached_response).not_to be_fresh
+    end
+  end
+end

data/spec/strategies/by_vary_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Faraday::HttpCache::Strategies::ByVary do
+  let(:vary_index_cache_key) { '64896419583e8022efeb21d0ece6e266c0e58b59' }
+  let(:cache_key) { '25230d75622fffc4f4de8a6af69e6e3764f7eb6f' }
+  let(:vary) { '' }
+  let(:request) do
+    env = {method: :get, url: 'http://test/index'}
+    double(env.merge(serializable_hash: env))
+  end
+
+  let(:response_payload) { {response_headers: {'Vary' => vary}} }
+
+  let(:response) do
+    instance_double(Faraday::HttpCache::Response, payload: response_payload, serializable_hash: response_payload)
+  end
+
+  let(:cache) { Faraday::HttpCache::MemoryStore.new }
+
+  let(:strategy) { described_class.new(store: cache) }
+  subject { strategy }
+
+  describe 'storing responses' do
+    shared_examples 'A strategy with serialization' do
+      it 'writes the response object to the underlying cache' do
+        entry = serializer.dump(response.serializable_hash)
+        expect(cache).to receive(:write).with(vary_index_cache_key, vary)
+        expect(cache).to receive(:write).with(cache_key, entry)
+        subject.write(request, response)
+      end
+    end
+
+    context 'with the JSON serializer' do
+      let(:serializer) { JSON }
+      it_behaves_like 'A strategy with serialization'
+
+      context 'when ASCII characters in response cannot be converted to UTF-8', if: Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1') do
+        let(:response_payload) do
+          body = String.new("\u2665").force_encoding('ASCII-8BIT')
+          super().merge('body' => body)
+        end
+
+        it 'raises and logs a warning' do
+          logger = double(:logger, warn: nil)
+          strategy = described_class.new(logger: logger)
+
+          expect {
+            strategy.write(request, response)
+          }.to raise_error(::Encoding::UndefinedConversionError)
+          expect(logger).to have_received(:warn).with(
+            'Response could not be serialized: "\xE2" from ASCII-8BIT to UTF-8. Try using Marshal to serialize.'
+          )
+        end
+      end
+    end
+
+    context 'with the Marshal serializer' do
+      let(:vary_index_cache_key) { '6a7cb42440c10ef6edeb1826086a4d90b04103f0' }
+      let(:cache_key) { '45e0efd1a60d29ed69d6c6018dfcb96f58db89e0' }
+      let(:serializer) { Marshal }
+      let(:strategy) { described_class.new(store: cache, serializer: Marshal) }
+
+      it_behaves_like 'A strategy with serialization'
+    end
+  end
+
+  describe 'reading responses' do
+    let(:strategy) { described_class.new(store: cache, serializer: serializer) }
+
+    shared_examples 'A strategy with serialization' do
+      it 'returns nil if the response is not cached' do
+        expect(subject.read(request)).to be_nil
+      end
+
+      it 'decodes a stored response' do
+        subject.write(request, response)
+
+        expect(subject.read(request)).to be_a(Faraday::HttpCache::Response)
+      end
+    end
+
+    context 'with the JSON serializer' do
+      let(:serializer) { JSON }
+
+      it_behaves_like 'A strategy with serialization'
+    end
+
+    context 'with the Marshal serializer' do
+      let(:serializer) { Marshal }
+
+      it_behaves_like 'A strategy with serialization'
+    end
+  end
+
+  describe 'deleting responses' do
+    it 'ignores delete method' do
+      subject.write(request, response)
+      subject.delete(request.url)
+      expect(subject.read(request)).not_to be_nil
+    end
+  end
+
+  describe 'remove age before caching and normalize max-age if non-zero age present' do
+    it 'is fresh if the response still has some time to live' do
+      headers = {
+        'Age' => 6,
+        'Cache-Control' => 'public, max-age=40',
+        'Date' => (Time.now - 38).httpdate,
+        'Expires' => (Time.now - 37).httpdate,
+        'Last-Modified' => (Time.now - 300).httpdate
+      }
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
+      expect(response).to be_fresh
+      subject.write(request, response)
+
+      cached_response = subject.read(request)
+      expect(cached_response.max_age).to eq(34)
+      expect(cached_response).not_to be_fresh
+    end
+
+    it 'is fresh until cached and that 1 second elapses then the response is no longer fresh' do
+      headers = {
+        'Date' => (Time.now - 39).httpdate,
+        'Expires' => (Time.now + 40).httpdate
+      }
+
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
+      expect(response).to be_fresh
+      subject.write(request, response)
+
+      sleep(1)
+      cached_response = subject.read(request)
+      expect(cached_response).not_to be_fresh
+    end
+  end
+end

data/spec/support/test_app.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'sinatra/base'
 require 'json'
 
@@ -27,7 +28,7 @@ class TestApp < Sinatra::Base
   end
 
   get '/image' do
-    image = File.expand_path('../empty.png', __FILE__)
+    image = File.expand_path('empty.png', __dir__)
     data  = IO.binread(image)
     [200, { 'Cache-Control' => 'max-age=400', 'Content-Type' => 'image/png' }, data]
   end