Provide option to limit number of cached entries per key

Related #112

lib/faraday/http_cache.rb

@@ -83,6 +83,7 @@ class HttpCache < Faraday::Middleware
     # :instrumenter    - An instrumentation object that should respond to 'instrument'.
     # :instrument_name - The String name of the instrument being reported on (optional).
     # :logger          - A logger object.
+    # :max_entries     - The maximum number of entries to store per cache key.
     #
     # Examples:
     #
@@ -99,14 +100,14 @@ class HttpCache < Faraday::Middleware
     #   # 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, store: nil, serializer: nil, shared_cache: true, instrumenter: nil, instrument_name: EVENT_NAME, logger: nil, max_entries: nil) # rubocop:disable Metrics/ParameterLists
       super(app)
 
       @logger = logger
       @shared_cache = shared_cache
       @instrumenter = instrumenter
       @instrument_name = instrument_name
-      @storage = Storage.new(store: store, serializer: serializer, logger: logger)
+      @storage = Storage.new(store: store, serializer: serializer, logger: logger, max_entries: max_entries)
     end
 
     # Public: Process the request into a duplicate of this instance to

lib/faraday/http_cache/storage.rb

@@ -23,15 +23,17 @@ class Storage
 
       # Internal: Initialize a new Storage object with a cache backend.
       #
-      # :logger     - A Logger object to be used to emit warnings.
-      # :store      - An cache store object that should respond to 'read',
-      #              'write', and 'delete'.
-      # :serializer - A serializer object that should respond to 'dump'
-      #               and 'load'.
-      def initialize(store: nil, serializer: nil, logger: nil)
+      # :logger      - A Logger object to be used to emit warnings.
+      # :store       - An cache store object that should respond to 'read',
+      #               'write', and 'delete'.
+      # :serializer  - A serializer object that should respond to 'dump'
+      #                and 'load'.
+      # :max_entries - The maximum number of entries per cache key.
+      def initialize(store: nil, serializer: nil, logger: nil, max_entries: nil)
         @cache = store || MemoryStore.new
         @serializer = serializer || JSON
         @logger = logger
+        @max_entries = max_entries
         assert_valid_store!
       end
 
@@ -55,6 +57,8 @@ def write(request, response)
 
         entries << entry
 
+        entries = entries.last(@max_entries) unless @max_entries.nil?
+
         cache.write(key, entries)
       rescue ::Encoding::UndefinedConversionError => e
         warn "Response could not be serialized: #{e.message}. Try using Marshal to serialize."

spec/storage_spec.rb

@@ -11,8 +11,10 @@
   let(:response) { double(serializable_hash: { response_headers: {} }) }
 
   let(:cache) { Faraday::HttpCache::MemoryStore.new }
+  let(:serializer) { nil }
+  let(:max_entries) { nil }
+  let(:storage) { Faraday::HttpCache::Storage.new(store: cache, serializer: serializer, max_entries: max_entries) }
 
-  let(:storage) { Faraday::HttpCache::Storage.new(store: cache) }
   subject { storage }
 
   describe 'Cache configuration' do
@@ -37,10 +39,33 @@
         expect(cache).to receive(:write).with(cache_key, [entry])
         subject.write(request, response)
       end
+
+      context 'with max_entries set' do
+        let(:max_entries) { 2 }
+        let(:response) { double(serializable_hash: { response_headers: { 'Vary' => 'X-Foo' } }) }
+
+        it 'limits the number of cached entries' do
+          requests = Array.new(max_entries + 1) do |i|
+            env = { method: :get, url: 'http://test/index', headers: { 'X-Foo' => i } }
+            double(env.merge(serializable_hash: env))
+          end
+
+          requests.each { |request| subject.write(request, response) }
+
+          expect(subject.cache.read(cache_key).count).to eq(max_entries)
+
+          expect(subject.read(requests.first)).to eq(nil)
+
+          requests.last(max_entries).each do |request|
+            expect(subject.read(request)).not_to be_nil
+          end
+        end
+      end
     end
 
     context 'with the JSON serializer' do
       let(:serializer) { JSON }
+
       it_behaves_like 'A storage with serialization'
 
       context 'when ASCII characters in response cannot be converted to UTF-8' do
@@ -66,7 +91,6 @@
     context 'with the Marshal serializer' do
       let(:cache_key) { '337d1e9c6c92423dd1c48a23054139058f97be40' }
       let(:serializer) { Marshal }
-      let(:storage) { Faraday::HttpCache::Storage.new(store: cache, serializer: Marshal) }
 
       it_behaves_like 'A storage with serialization'
     end