faraday-http-cache 0.4.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 63e018cc1939d1fefb02b7d90f810a71afdd15b9
-  data.tar.gz: 408cdbabae9f4a6d144b0c799341bf4c7a46adea
+  metadata.gz: f34a3a6ee332a8ce2480f41e1071020237c0ae1e
+  data.tar.gz: e1fc2519d29fc6656e156ffa4d9bf722e8b17297
 SHA512:
-  metadata.gz: 5247068c970b755688f710a557a4d6e6366cbb909c303f16a67e1cb1814240e6a709b4b7bba3d75048c31b0c716b36ce34b4b85152455e9d13e299e92be08ead
-  data.tar.gz: bfe06e86bdd004958ac7ca444c346f3fd5060fa8d61e54e66075464c215afb3bca14e7c5ed10714bd78ebc79a77e7aab7bdb2326b1e919e3b442d7980ff5aabe
+  metadata.gz: aa4045303477608539cc6f844daf4ebade16ac4e3e4ba7ecc5c11a4f9f096c4895893f773708607826dc1428b50814cf5e6e1298330e36f6e5c4f3cc8d5a817c
+  data.tar.gz: f56ed4f205684f471a39fd471b107e3fb417ffcdb945af2c67ad5d018958bbc93873076e0eeab0b97ac6f4984243aba5d27bf73246480c0a1e675e4009bfbc8c

data/lib/faraday/http_cache.rb

@@ -1,6 +1,7 @@
 require 'faraday'
 
 require 'faraday/http_cache/storage'
+require 'faraday/http_cache/request'
 require 'faraday/http_cache/response'
 
 module Faraday
@@ -38,7 +39,11 @@ module Faraday
   #   end
   class HttpCache < Faraday::Middleware
     # Internal: valid options for the 'initialize' configuration Hash.
-    VALID_OPTIONS = [:store, :serializer, :logger, :store_options, :shared_cache]
+    VALID_OPTIONS = [:store, :serializer, :logger, :shared_cache]
+
+    UNSAFE_METHODS = [:post, :put, :delete, :patch]
+
+    ERROR_STATUSES = 400..499
 
     # Public: Initializes a new HttpCache middleware.
     #
@@ -48,7 +53,6 @@ module Faraday
     #             :serializer    - A serializer that should respond to 'dump' and 'load'.
     #             :shared_cache  - A flag to mark the middleware as a shared cache or not.
     #             :store         - A cache store that should respond to 'read' and 'write'.
-    #             :store_options - Deprecated: additional options to setup the cache store.
     #
     # Examples:
     #
@@ -65,20 +69,13 @@ 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, *args)
+    def initialize(app, options = {})
       super(app)
-      @logger = nil
-      @shared_cache = true
-      if args.first.is_a? Hash
-        options = args.first
-        @logger = options[:logger]
-        @shared_cache = options.fetch(:shared_cache, true)
-      else
-        options = parse_deprecated_options(*args)
-      end
-
       assert_valid_options!(options)
-      @storage = Storage.new(options)
+
+      @logger = options[:logger]
+      @shared_cache = options.fetch(:shared_cache, true)
+      @storage = create_storage(options)
     end
 
     # Public: Process the request into a duplicate of this instance to
@@ -103,86 +100,58 @@ module Faraday
 
       response = nil
 
-      if can_cache?(@request[:method])
-        response = process(env)
+      if @request.cacheable?
+        response = if @request.no_cache?
+          trace :bypass
+          @app.call(env).on_complete do |fresh_env|
+            response = Response.new(create_response(fresh_env))
+            store(response)
+          end
+        else
+          process(env)
+        end
       else
         trace :unacceptable
         response = @app.call(env)
       end
 
       response.on_complete do
+        delete(@request, response) if should_delete?(response.status, @request.method)
         log_request
       end
     end
 
-    # Internal: Should this cache instance act like a "shared cache" according
-    # to the the definition in RFC 2616?
-    def shared_cache?
-      @shared_cache
-    end
+    protected
 
-    private
-    # Internal: Receive the deprecated arguments to initialize the old API
-    # and returns a Hash compatible with the new API
-    #
-    # Examples:
-    #
-    #   parse_deprecated_options(Rails.cache)
-    #   # => { store: Rails.cache }
-    #
-    #   parse_deprecated_options(:mem_cache_store)
-    #   # => { store: :mem_cache_store }
-    #
-    #   parse_deprecated_options(:mem_cache_store, logger: Rails.logger)
-    #   # => { store: :mem_cache_store, logger: Rails.logger }
-    #
-    #   parse_deprecated_options(:mem_cache_store, 'localhost:11211')
-    #   # => { store: :mem_cache_store, store_options: ['localhost:11211] }
-    #
-    #   parse_deprecated_options(:mem_cache_store, logger: Rails.logger, serializer: Marshal)
-    #   # => { store: :mem_cache_store, logger: Rails.logger, serializer: Marshal }
-    #
-    #   parse_deprecated_options(serializer: Marshal)
-    #   # => { serializer: Marshal }
-    #
-    #   parse_deprecated_options(:file_store, { serializer: Marshal }, 'tmp')
-    #   # => { store: :file_store, serializer: Marshal, store_options: ['tmp'] }
-    #
-    #   parse_deprecated_options(:memory_store, size: 1024)
-    #   # => { store: :memory_store, store_options: [size: 1024] }
-    #
-    # Returns a hash with the following keys:
-    #   - store
-    #   - serializer
-    #   - logger
-    #   - store_options
-    #
-    # In order to check what each key means, check `Storage#initialize` description.
-    def parse_deprecated_options(*args)
-      options = {}
-      if args.length > 0
-        Kernel.warn('DEPRECATION WARNING: This API is deprecated, refer to the documentation for the new one', caller)
-      end
+    # Internal: Gets the request object created from the Faraday env Hash.
+    attr_reader :request
 
-      options[:store] = args.shift
+    # Internal: Gets the storage instance associated with the middleware.
+    attr_reader :storage
 
-      if args.first.is_a? Hash
-        hash_params = args.first
-        options[:serializer] = hash_params.delete(:serializer)
+    # Public: Creates the Storage instance for this middleware.
+    #
+    # options - A Hash of options.
+    #
+    # Returns a Storage instance.
+    def create_storage(options)
+      Storage.new(options)
+    end
 
-        @logger = hash_params[:logger]
-        @shared_cache = hash_params.fetch(:shared_cache, true)
-      end
+    private
 
-      options[:store_options] = args
-      options
+    # Internal: Should this cache instance act like a "shared cache" according
+    # to the the definition in RFC 2616?
+    def shared_cache?
+      @shared_cache
     end
 
-    # Internal: Validates if the current request method is valid for caching.
+    # Internal: Checks if the current request method should remove any existing
+    # cache entries for the same resource.
     #
-    # Returns true if the method is ':get' or ':head'.
-    def can_cache?(method)
-      method == :get || method == :head
+    # Returns true or false.
+    def should_delete?(status, method)
+      UNSAFE_METHODS.include?(method) && !ERROR_STATUSES.cover?(status)
     end
 
     # Internal: Tries to locate a valid response or forwards the call to the stack.
@@ -266,6 +235,17 @@ module Faraday
       end
     end
 
+    def delete(request, response)
+      headers = %w(Location Content-Location)
+      headers.each do |header|
+        url = response.headers[header]
+        @storage.delete(url) if url
+      end
+
+      @storage.delete(request.url)
+      trace :delete
+    end
+
     # Internal: Fetches the response from the Faraday stack and stores it.
     #
     # env - the environment 'Hash' from the Faraday stack.
@@ -295,20 +275,8 @@ module Faraday
       }
     end
 
-    # Internal: Creates a new 'Hash' containing the request information.
-    #
-    # env - the environment 'Hash' from the Faraday stack.
-    #
-    # Returns a 'Hash' containing the ':method', ':url' and 'request_headers'
-    # entries.
     def create_request(env)
-      hash = env.to_hash
-
-      {
-        method: hash[:method],
-        url: hash[:url],
-        request_headers: hash[:request_headers].dup
-      }
+      Request.from_env(env)
     end
 
     # Internal: Logs the trace info about the incoming request
@@ -319,8 +287,8 @@ module Faraday
     def log_request
       return unless @logger
 
-      method = @request[:method].to_s.upcase
-      path = @request[:url].request_uri
+      method = @request.method.to_s.upcase
+      path = @request.url.request_uri
       line = "HTTP Cache: [#{method} #{path}] #{@trace.join(', ')}"
       @logger.debug(line)
     end

data/lib/faraday/http_cache/request.rb

@@ -0,0 +1,46 @@
+module Faraday
+  class HttpCache < Faraday::Middleware
+    # Internal: A class to represent a request
+    class Request
+
+      class << self
+        def from_env(env)
+          hash = env.to_hash
+          new(method: hash[:method], url: hash[:url], headers: hash[:request_headers].dup)
+        end
+      end
+
+      attr_reader :method, :url, :headers
+
+      def initialize(options)
+        @method, @url, @headers = options[:method], options[:url], options[:headers]
+      end
+
+      # Internal: Validates if the current request method is valid for caching.
+      #
+      # Returns true if the method is ':get' or ':head'.
+      def cacheable?
+        return false if method != :get && method != :head
+        return false if cache_control.no_store?
+        true
+      end
+
+      def no_cache?
+        cache_control.no_cache?
+      end
+
+      # Internal: Gets the 'CacheControl' object.
+      def cache_control
+        @cache_control ||= CacheControl.new(headers['Cache-Control'])
+      end
+
+      def serializable_hash
+        {
+          method: @method,
+          url: @url,
+          headers: @headers
+        }
+      end
+    end
+  end
+end

data/lib/faraday/http_cache/storage.rb

@@ -16,6 +16,9 @@ module Faraday
     #   # Creates a new Storage using Marshal for serialization.
     #   Faraday::HttpCache::Storage.new(:memory_store, serializer: Marshal)
     class Storage
+      # Public: Gets the underlying cache store object.
+      attr_reader :cache
+
       # Internal: Initialize a new Storage object with a cache backend.
       #
       # options - Storage options (default: {}).
@@ -24,96 +27,131 @@ module Faraday
       #                            respond to 'dump' and 'load'.
       #           :serializer    - A serializer object that should
       #                            respond to 'dump' and 'load'.
-      #           :store_options - An array containg the options for
-      #                            the cache store.
       def initialize(options = {})
         @cache = options[:store] || MemoryStore.new
         @serializer = options[:serializer] || JSON
         @logger = options[:logger]
-        if @cache.is_a? Symbol
-          @cache = lookup_store(@cache, options[:store_options])
-        end
         assert_valid_store!
       end
 
-      # Internal: Writes a response with a key based on the given request.
+      # Internal: Store a response inside the cache.
       #
-      # request - The Hash containing the request information.
-      #           :method          - The HTTP Method used for the request.
-      #           :url             - The requested URL.
-      #           :request_headers - The custom headers for the request.
+      # request  - A Faraday::HttpCache::::Request instance of the executed HTTP
+      #            request.
       # response - The Faraday::HttpCache::Response instance to be stored.
+      #
+      # Returns nothing.
       def write(request, response)
-        key = cache_key_for(request)
-        value = @serializer.dump(response.serializable_hash)
-        @cache.write(key, value)
-      rescue Encoding::UndefinedConversionError => e
-        if @logger
-          @logger.warn("Response could not be serialized: #{e.message}. Try using Marshal to serialize.")
+        key = cache_key_for(request.url)
+        entry = serialize_entry(request.serializable_hash, response.serializable_hash)
+
+        entries = cache.read(key) || []
+
+        entries.reject! do |(cached_request, cached_response)|
+          response_matches?(request, deserialize_object(cached_request), deserialize_object(cached_response))
         end
-        raise
+
+        entries << entry
+
+        cache.write(key, entries)
+      rescue Encoding::UndefinedConversionError => e
+        warn "Response could not be serialized: #{e.message}. Try using Marshal to serialize."
+        raise e
       end
 
-      # Internal: Reads a key based on the given request from the underlying cache.
+      # Internal: Attempt to retrieve an stored response that suits the incoming
+      # HTTP request.
+      #
+      # request  - A Faraday::HttpCache::::Request instance of the incoming HTTP
+      #            request.
+      # klass    - The Class to be instantiated with the stored response.
       #
-      # request - The Hash containing the request information.
-      #           :method          - The HTTP Method used for the request.
-      #           :url             - The requested URL.
-      #           :request_headers - The custom headers for the request.
-      # klass - The Class to be instantiated with the recovered informations.
+      # Returns an instance of 'klass'.
       def read(request, klass = Faraday::HttpCache::Response)
-        cache_key = cache_key_for(request)
-        found = @cache.read(cache_key)
-
-        if found
-          payload = @serializer.load(found).each_with_object({}) do |(key,value), hash|
-            hash[key.to_sym] = value
-          end
+        cache_key = cache_key_for(request.url)
+        entries = cache.read(cache_key)
+        response = lookup_response(request, entries)
 
-          klass.new(payload)
+        if response
+          klass.new(response)
         end
       end
 
+      def delete(url)
+        cache_key = cache_key_for(url)
+        cache.delete(cache_key)
+      end
+
       private
 
-      # Internal: Generates a String key for a given request object.
+      # Internal: Retrieve a response Hash from the list of entries that match
+      # the given request.
       #
-      # Returns the digested String.
-      def cache_key_for(request)
-        digest = Digest::SHA1.new
-        digest.update 'method'
-        digest.update request[:method].to_s
-        digest.update 'request_headers'
-        request[:request_headers].keys.sort.each do |key|
-          digest.update key.to_s
-          digest.update request[:request_headers][key].to_s
+      # request  - A Faraday::HttpCache::::Request instance of the incoming HTTP
+      #            request.
+      # entries  - An Array of pairs of Hashes (request, response).
+      #
+      # Returns a Hash or nil.
+      def lookup_response(request, entries)
+        if entries
+          entries = entries.map { |entry| deserialize_entry(*entry) }
+          _, response = entries.find { |req, res| response_matches?(request, req, res) }
+          response
         end
-        digest.update 'url'
-        digest.update request[:url].to_s
-
-        digest.to_s
       end
 
-      # Internal: Creates a cache store from 'ActiveSupport' with a set of options.
+      # Internal: Check if a cached response and request matches the given
+      # request.
       #
-      # store   - A 'Symbol' with the store name.
-      # options - Additional options for the cache store.
+      # request         - A Faraday::HttpCache::::Request instance of the
+      #                   current HTTP request.
+      # cached_request  - The Hash of the request that was cached.
+      # cached_response - The Hash of the response that was cached.
       #
-      # Returns an 'ActiveSupport::Cache' store.
-      def lookup_store(store, options)
-        if @logger
-          @logger.warn "Passing a Symbol as the 'store' is deprecated, please pass the cache store instead."
-        end
+      # Returns true or false.
+      def response_matches?(request, cached_request, cached_response)
+        request.method.to_s == cached_request[:method] &&
+          vary_matches?(cached_response, request, cached_request)
+      end
 
-        begin
-          require 'active_support/cache'
-          ActiveSupport::Cache.lookup_store(store, options)
-        rescue LoadError => e
-          puts "You're missing the 'activesupport' gem. Add it to your Gemfile, bundle it and try again"
-          raise e
+      def vary_matches?(cached_response, request, cached_request)
+        headers = Faraday::Utils::Headers.new(cached_response[:response_headers])
+        vary = headers['Vary'].to_s
+
+        vary.empty? || (vary != '*' && vary.split(/[\s,]+/).all? do |header|
+          request.headers[header] == cached_request[:headers][header]
+        end)
+      end
+
+      def serialize_entry(*objects)
+        objects.map { |object| serialize_object(object) }
+      end
+
+      def serialize_object(object)
+        @serializer.dump(object)
+      end
+
+      def deserialize_entry(*objects)
+        objects.map { |object| deserialize_object(object) }
+      end
+
+      def deserialize_object(object)
+        @serializer.load(object).each_with_object({}) do |(key, value), hash|
+          hash[key.to_sym] = value
         end
       end
 
+      # Internal: Computes the cache key for a specific request, taking in
+      # account the current serializer to avoid cross serialization issues.
+      #
+      # url - The request URL.
+      #
+      # Returns a String.
+      def cache_key_for(url)
+        prefix = (@serializer.is_a?(Module) ? @serializer : @serializer.class).name
+        Digest::SHA1.hexdigest("#{prefix}#{url}")
+      end
+
       # Internal: Checks if the given cache object supports the
       # expect API ('read' and 'write').
       #
@@ -121,10 +159,14 @@ module Faraday
       #
       # Returns nothing.
       def assert_valid_store!
-        unless @cache.respond_to?(:read) && @cache.respond_to?(:write)
-          raise ArgumentError.new("#{@cache.inspect} is not a valid cache store as it does not responds to 'read' and 'write'.")
+        unless cache.respond_to?(:read) && cache.respond_to?(:write) && cache.respond_to?(:delete)
+          raise ArgumentError.new("#{cache.inspect} is not a valid cache store as it does not responds to 'read', 'write' or 'delete'.")
         end
       end
+
+      def warn(message)
+        @logger.warn(message) if @logger
+      end
     end
 
     # Internal: A Hash based store to be used by the 'Storage' class
@@ -138,6 +180,10 @@ module Faraday
         @cache[key]
       end
 
+      def delete(key)
+        @cache.delete(key)
+      end
+
       def write(key, value)
         @cache[key] = value
       end

data/spec/{middleware_spec.rb → http_cache_spec.rb}

@@ -23,7 +23,7 @@ describe Faraday::HttpCache do
   end
 
   it 'logs that a POST request is unacceptable' do
-    expect(logger).to receive(:debug).with('HTTP Cache: [POST /post] unacceptable')
+    expect(logger).to receive(:debug).with('HTTP Cache: [POST /post] unacceptable, delete')
     client.post('post').body
   end
 
@@ -32,9 +32,73 @@ describe Faraday::HttpCache do
     expect(client.get('broken').body).to eq('2')
   end
 
-  it 'logs that a response with a bad status code is invalid' do
-    expect(logger).to receive(:debug).with('HTTP Cache: [GET /broken] miss, invalid')
-    client.get('broken')
+  describe 'cache invalidation' do
+    it 'expires POST requests' do
+      client.get('counter')
+      client.post('counter')
+      expect(client.get('counter').body).to eq('2')
+    end
+
+    it 'logs that a POST request was deleted from the cache' do
+      expect(logger).to receive(:debug).with('HTTP Cache: [POST /counter] unacceptable, delete')
+      client.post('counter')
+    end
+
+    it 'does not expires POST requests that failed' do
+      client.get('get')
+      client.post('get')
+      expect(client.get('get').body).to eq('1')
+    end
+
+    it 'expires PUT requests' do
+      client.get('counter')
+      client.put('counter')
+      expect(client.get('counter').body).to eq('2')
+    end
+
+    it 'logs that a PUT request was deleted from the cache' do
+      expect(logger).to receive(:debug).with('HTTP Cache: [PUT /counter] unacceptable, delete')
+      client.put('counter')
+    end
+
+    it 'expires DELETE requests' do
+      client.get('counter')
+      client.delete('counter')
+      expect(client.get('counter').body).to eq('2')
+    end
+
+    it 'logs that a DELETE request was deleted from the cache' do
+      expect(logger).to receive(:debug).with('HTTP Cache: [DELETE /counter] unacceptable, delete')
+      client.delete('counter')
+    end
+
+    it 'expires PATCH requests' do
+      client.get('counter')
+      client.patch('counter')
+      expect(client.get('counter').body).to eq('2')
+    end
+
+    it 'logs that a PATCH request was deleted from the cache' do
+      expect(logger).to receive(:debug).with('HTTP Cache: [PATCH /counter] unacceptable, delete')
+      client.patch('counter')
+    end
+
+    it 'logs that a response with a bad status code is invalid' do
+      expect(logger).to receive(:debug).with('HTTP Cache: [GET /broken] miss, invalid')
+      client.get('broken')
+    end
+
+    it 'expires entries for the "Location" header' do
+      client.get('get')
+      client.post('delete-with-location')
+      expect(client.get('get').body).to eq('2')
+    end
+
+    it 'expires entries for the "Content-Location" header' do
+      client.get('get')
+      client.post('delete-with-content-location')
+      expect(client.get('get').body).to eq('2')
+    end
   end
 
   describe 'when acting as a shared cache' do
@@ -65,7 +129,7 @@ describe Faraday::HttpCache do
     end
   end
 
-  it 'does not cache requests with a explicit no-store directive' do
+  it 'does not cache responses with a explicit no-store directive' do
     client.get('dontstore')
     expect(client.get('dontstore').body).to eq('2')
   end
@@ -75,10 +139,22 @@ describe Faraday::HttpCache do
     client.get('dontstore')
   end
 
-  it 'caches multiple responses when the headers differ' do
+  it 'does not caches multiple responses when the headers differ' do
     client.get('get', nil, 'HTTP_ACCEPT' => 'text/html')
     expect(client.get('get', nil, 'HTTP_ACCEPT' => 'text/html').body).to eq('1')
-    expect(client.get('get', nil, 'HTTP_ACCEPT' => 'application/json').body).to eq('2')
+    expect(client.get('get', nil, 'HTTP_ACCEPT' => 'application/json').body).to eq('1')
+  end
+
+  it 'caches multiples responses based on the "Vary" header' do
+    client.get('vary', nil, 'User-Agent' => 'Agent/1.0')
+    expect(client.get('vary', nil, 'User-Agent' => 'Agent/1.0').body).to eq('1')
+    expect(client.get('vary', nil, 'User-Agent' => 'Agent/2.0').body).to eq('2')
+    expect(client.get('vary', nil, 'User-Agent' => 'Agent/3.0').body).to eq('3')
+  end
+
+  it 'never caches responses with the wildcard "Vary" header' do
+    client.get('vary-wildcard')
+    expect(client.get('vary-wildcard').body).to eq('2')
   end
 
   it 'caches requests with the "Expires" header' do
@@ -96,6 +172,18 @@ describe Faraday::HttpCache do
     expect(client.get('get').body).to eq('1')
   end
 
+  context 'when the request has a "no-cache" directive' do
+    it 'by-passes the cache' do
+      client.get('get', nil, 'Cache-Control' => 'no-cache')
+      expect(client.get('get', nil, 'Cache-Control' => 'no-cache').body).to eq('2')
+    end
+
+    it 'caches the response' do
+      client.get('get', nil, 'Cache-Control' => 'no-cache')
+      expect(client.get('get', nil).body).to eq('1')
+    end
+  end
+
   it 'logs that a GET response is stored' do
     expect(logger).to receive(:debug).with('HTTP Cache: [GET /get] miss, store')
     client.get('get')
@@ -190,51 +278,5 @@ describe Faraday::HttpCache do
       expect(Faraday::HttpCache::Storage).to receive(:new).with(store: store)
       Faraday::HttpCache.new(app, store: store)
     end
-
-    it 'accepts a Hash option' do
-      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, [{ size: 1024 }]).and_call_original
-      Faraday::HttpCache.new(app, store: :memory_store, store_options: [size: 1024])
-    end
-
-    it 'consumes the "logger" key' do
-      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, nil).and_call_original
-      Faraday::HttpCache.new(app, store: :memory_store, logger: logger)
-    end
-
-    describe '#shared_cache?' do
-      it 'is true by default' do
-        expect(Faraday::HttpCache.new(app).shared_cache?).to eq(true)
-      end
-
-      it 'is true when configured to true' do
-        expect(Faraday::HttpCache.new(app, shared_cache: true).shared_cache?).to eq(true)
-      end
-
-      it 'is false when configured to be false' do
-        expect(Faraday::HttpCache.new(app, shared_cache: false).shared_cache?).to eq(false)
-      end
-    end
-
-    context 'with deprecated options format' do
-      before do
-        allow(Kernel).to receive(:warn)
-      end
-
-      it 'uses the options to create a Cache Store' do
-        expect(ActiveSupport::Cache).to receive(:lookup_store).with(:file_store, ['tmp']).and_call_original
-        Faraday::HttpCache.new(app, :file_store, 'tmp')
-      end
-
-      it 'accepts a Hash option' do
-        expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, [{ size: 1024 }]).and_call_original
-        Faraday::HttpCache.new(app, :memory_store, size: 1024)
-      end
-
-      it 'warns the user about the deprecated options' do
-        expect(Kernel).to receive(:warn)
-
-        Faraday::HttpCache.new(app, :memory_store, logger: logger)
-      end
-    end
   end
 end

data/spec/request_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Faraday::HttpCache::Request do
+  subject { Faraday::HttpCache::Request.new method: method, url: url, headers: headers }
+  let(:method) { :get }
+  let(:url) { URI.parse('http://example.com/path/to/somewhere') }
+  let(:headers) { {} }
+
+  context 'a GET request' do
+    it { should be_cacheable }
+  end
+
+  context 'a HEAD request' do
+    let(:method) { :head }
+    it { should be_cacheable }
+  end
+
+  context 'a POST request' do
+    let(:method) { :post }
+    it { should_not be_cacheable }
+  end
+
+  context 'a PUT request' do
+    let(:method) { :put }
+    it { should_not be_cacheable }
+  end
+
+  context 'an OPTIONS request' do
+    let(:method) { :options }
+    it { should_not be_cacheable }
+  end
+
+  context 'a DELETE request' do
+    let(:method) { :delete }
+    it { should_not be_cacheable }
+  end
+
+  context 'a TRACE request' do
+    let(:method) { :trace }
+    it { should_not be_cacheable }
+  end
+
+  context 'with "Cache-Control: no-store"' do
+    let(:headers) { { 'Cache-Control' => 'no-store' } }
+    it { should_not be_cacheable }
+  end
+
+end

data/spec/storage_spec.rb

@@ -1,13 +1,15 @@
 require 'spec_helper'
 
 describe Faraday::HttpCache::Storage do
+  let(:cache_key) { '6e3b941d0f7572291c777b3e48c04b74124a55d0' }
   let(:request) do
-    { method: :get, request_headers: {}, url: URI.parse('http://foo.bar/') }
+    env = { method: :get, url: 'http://test/index' }
+    double(env.merge(serializable_hash: env))
   end
 
-  let(:response) { double(serializable_hash: {}) }
+  let(:response) { double(serializable_hash: { response_headers: {} }) }
 
-  let(:cache) { ActiveSupport::Cache.lookup_store }
+  let(:cache) { Faraday::HttpCache::MemoryStore.new }
 
   let(:storage) { Faraday::HttpCache::Storage.new(store: cache) }
   subject { storage }
@@ -18,17 +20,6 @@ describe Faraday::HttpCache::Storage do
       Faraday::HttpCache::Storage.new
     end
 
-    it 'lookups an ActiveSupport cache store if a Symbol is given' do
-      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:file_store, ['/tmp']).and_call_original
-      Faraday::HttpCache::Storage.new(store: :file_store, store_options: ['/tmp'])
-    end
-
-    it 'emits a warning when doing the lookup of an ActiveSupport cache store' do
-      logger = double
-      expect(logger).to receive(:warn).with(/Passing a Symbol as the 'store' is deprecated/)
-      Faraday::HttpCache::Storage.new(store: :file_store, logger: logger)
-    end
-
     it 'raises an error when the given store is not valid' do
       wrong = double
 
@@ -39,20 +30,19 @@ describe Faraday::HttpCache::Storage do
   end
 
   describe 'storing responses' do
-
-    shared_examples 'serialization' do
-      it 'writes the response json to the underlying cache using a digest as the key' do
-        expect(cache).to receive(:write).with(cache_key, serialized)
+    shared_examples 'A storage 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 default serializer' do
-      let(:serialized) { JSON.dump(response.serializable_hash) }
-      let(:cache_key)  { '084dd517af7651a9ca7823728544b9b55e0cc130' }
-      it_behaves_like 'serialization'
+    context 'with the JSON serializer' do
+      let(:serializer) { JSON }
+      it_behaves_like 'A storage with serialization'
 
-      context 'with ASCII character in response that cannot be converted to UTF-8' do
+      context 'when ASCII characters in response cannot be converted to UTF-8' do
         let(:response) do
           body = "\u2665".force_encoding('ASCII-8BIT')
           double(:response, serializable_hash: { 'body' => body })
@@ -70,22 +60,12 @@ describe Faraday::HttpCache::Storage do
       end
     end
 
-    context 'with Marshal serializer' do
-      let(:storage)    { Faraday::HttpCache::Storage.new store: cache, serializer: Marshal }
-      let(:serialized) { Marshal.dump(response.serializable_hash) }
-      let(:cache_key) { '084dd517af7651a9ca7823728544b9b55e0cc130' }
-
-      it_behaves_like 'serialization'
-
-      it 'should have a unique cache key' do
-        request = { method: :get, request_headers: {}, url: URI.parse('http://foo.bar/path/to/somewhere') }
-        duplicate_request = { method: :get, request_headers: {}, url: URI.parse('http://foo.bar/path/to/somewhere') }
-        storage = Faraday::HttpCache::Storage.new(serializer: Marshal)
-        response = Faraday::HttpCache::Response.new(status: 200, body: 'body')
-        storage.write(request, response)
-        read_response  = storage.read(duplicate_request).serializable_hash
-        expect(read_response).to eq(response.serializable_hash)
-      end
+    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
   end
 
@@ -101,6 +81,14 @@ describe Faraday::HttpCache::Storage do
     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 = {

data/spec/support/test_app.rb

@@ -40,10 +40,38 @@ class TestApp < Sinatra::Base
     [500, { 'Cache-Control' => 'max-age=400' }, increment_counter]
   end
 
+  get '/counter' do
+    [200, { 'Cache-Control' => 'max-age=200' }, increment_counter]
+  end
+
+  post '/counter' do
+  end
+
+  put '/counter' do
+  end
+
+  delete '/counter' do
+  end
+
+  patch '/counter' do
+  end
+
   get '/get' do
     [200, { 'Cache-Control' => 'max-age=200' }, increment_counter]
   end
 
+  post '/delete-with-location' do
+    [200, { 'Location' => "#{request.base_url}/get" }, '']
+  end
+
+  post '/delete-with-content-location' do
+    [200, { 'Content-Location' => "#{request.base_url}/get" }, '']
+  end
+
+  post '/get' do
+    halt 405
+  end
+
   get '/private' do
     [200, { 'Cache-Control' => 'private, max-age=100' }, increment_counter]
   end
@@ -82,6 +110,14 @@ class TestApp < Sinatra::Base
     end
   end
 
+  get '/vary' do
+    [200, { 'Cache-Control' => 'max-age=50', 'Vary' => 'User-Agent' }, increment_counter]
+  end
+
+  get '/vary-wildcard' do
+    [200, { 'Cache-Control' => 'max-age=50', 'Vary' => '*' }, increment_counter]
+  end
+
   # Increments the 'requests' counter to act as a newly processed response.
   def increment_counter
     (settings.requests += 1).to_s

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faraday-http-cache
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Lucas Mazza
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-17 00:00:00.000000000 Z
+date: 2015-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -36,12 +36,14 @@ files:
 - lib/faraday-http-cache.rb
 - lib/faraday/http_cache.rb
 - lib/faraday/http_cache/cache_control.rb
+- lib/faraday/http_cache/request.rb
 - lib/faraday/http_cache/response.rb
 - lib/faraday/http_cache/storage.rb
 - spec/binary_spec.rb
 - spec/cache_control_spec.rb
+- spec/http_cache_spec.rb
 - spec/json_spec.rb
-- spec/middleware_spec.rb
+- spec/request_spec.rb
 - spec/response_spec.rb
 - spec/spec_helper.rb
 - spec/storage_spec.rb
@@ -68,15 +70,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A Faraday middleware that stores and validates cache expiration.
 test_files:
 - spec/binary_spec.rb
 - spec/cache_control_spec.rb
+- spec/http_cache_spec.rb
 - spec/json_spec.rb
-- spec/middleware_spec.rb
+- spec/request_spec.rb
 - spec/response_spec.rb
 - spec/spec_helper.rb
 - spec/storage_spec.rb