faraday-http-cache 0.2.1 → 0.3.0

data/spec/json_spec.rb

@@ -1,21 +1,19 @@
 require 'spec_helper'
 
 describe Faraday::HttpCache do
-  let(:logger) { double('a Logger object', :debug => nil) }
-
   let(:client) do
-    Faraday.new(:url => ENV['FARADAY_SERVER']) do |stack|
-      stack.response :json, :content_type => /\bjson$/
-      stack.use :http_cache, :logger => logger
+    Faraday.new(url: ENV['FARADAY_SERVER']) do |stack|
+      stack.response :json, content_type: /\bjson$/
+      stack.use :http_cache
       adapter = ENV['FARADAY_ADAPTER']
       stack.headers['X-Faraday-Adapter'] = adapter
       stack.adapter adapter.to_sym
     end
   end
 
-  it "works fine with other middlewares" do
+  it 'works fine with other middlewares' do
     client.get('clear')
-    client.get('json').body['count'].should == 1
-    client.get('json').body['count'].should == 1
+    expect(client.get('json').body['count']).to eq(1)
+    expect(client.get('json').body['count']).to eq(1)
   end
 end

data/spec/middleware_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 describe Faraday::HttpCache do
-  let(:logger) { double('a Logger object', :debug => nil) }
+  let(:logger) { double('a Logger object', debug: nil) }
 
   let(:client) do
-    Faraday.new(:url => ENV['FARADAY_SERVER']) do |stack|
-      stack.use Faraday::HttpCache, :logger => logger
+    Faraday.new(url: ENV['FARADAY_SERVER']) do |stack|
+      stack.use Faraday::HttpCache, logger: logger
       adapter = ENV['FARADAY_ADAPTER']
       stack.headers['X-Faraday-Adapter'] = adapter
       stack.adapter adapter.to_sym
@@ -16,154 +16,181 @@ describe Faraday::HttpCache do
     client.get('clear')
   end
 
-  it "doesn't cache POST requests" do
+  it 'does not cache POST requests' do
     client.post('post').body
-    client.post('post').body.should == "2"
+    expect(client.post('post').body).to eq('2')
   end
 
-  it "logs that a POST request is unacceptable" do
-    logger.should_receive(:debug).with('HTTP Cache: [POST /post] unacceptable')
+  it 'logs that a POST request is unacceptable' do
+    expect(logger).to receive(:debug).with('HTTP Cache: [POST /post] unacceptable')
     client.post('post').body
   end
 
-  it "doesn't cache responses with invalid status code" do
+  it 'does not cache responses with invalid status code' do
     client.get('broken')
-    client.get('broken').body.should == "2"
+    expect(client.get('broken').body).to eq('2')
   end
 
-  it "logs that a response with a bad status code is invalid" do
-    logger.should_receive(:debug).with('HTTP Cache: [GET /broken] miss, invalid')
+  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 "doesn't cache requests with a private cache control" do
+  it 'does not cache requests with a private cache control' do
     client.get('private')
-    client.get('private').body.should == "2"
+    expect(client.get('private').body).to eq('2')
   end
 
-  it "logs that a private response is invalid" do
-    logger.should_receive(:debug).with('HTTP Cache: [GET /private] miss, invalid')
+  it 'logs that a private response is invalid' do
+    expect(logger).to receive(:debug).with('HTTP Cache: [GET /private] miss, invalid')
     client.get('private')
   end
 
-  it "doesn't cache requests with a explicit no-store directive" do
+  it 'does not cache requests with a explicit no-store directive' do
     client.get('dontstore')
-    client.get('dontstore').body.should == "2"
+    expect(client.get('dontstore').body).to eq('2')
   end
 
-  it "logs that a response with a no-store directive is invalid" do
-    logger.should_receive(:debug).with('HTTP Cache: [GET /dontstore] miss, invalid')
+  it 'logs that a response with a no-store directive is invalid' do
+    expect(logger).to receive(:debug).with('HTTP Cache: [GET /dontstore] miss, invalid')
     client.get('dontstore')
   end
 
-  it "caches multiple responses when the headers differ" do
+  it 'caches multiple responses when the headers differ' do
     client.get('get', nil, 'HTTP_ACCEPT' => 'text/html')
-    client.get('get', nil, 'HTTP_ACCEPT' => 'text/html').body.should == "1"
-
-    client.get('get', nil, 'HTTP_ACCEPT' => 'application/json').body.should == "2"
+    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')
   end
 
-  it "caches requests with the 'Expires' header" do
+  it 'caches requests with the "Expires" header' do
     client.get('expires')
-    client.get('expires').body.should == "1"
+    expect(client.get('expires').body).to eq('1')
   end
 
-  it "logs that a request with the 'Expires' is fresh and stored" do
-    logger.should_receive(:debug).with('HTTP Cache: [GET /expires] miss, store')
+  it 'logs that a request with the "Expires" is fresh and stored' do
+    expect(logger).to receive(:debug).with('HTTP Cache: [GET /expires] miss, store')
     client.get('expires')
   end
 
-  it "caches GET responses" do
+  it 'caches GET responses' do
     client.get('get')
-    client.get('get').body.should == "1"
+    expect(client.get('get').body).to eq('1')
   end
 
-  it "logs that a GET response is stored" do
-    logger.should_receive(:debug).with('HTTP Cache: [GET /get] miss, store')
+  it 'logs that a GET response is stored' do
+    expect(logger).to receive(:debug).with('HTTP Cache: [GET /get] miss, store')
     client.get('get')
   end
 
-  it "differs requests with different query strings in the log" do
-    logger.should_receive(:debug).with('HTTP Cache: [GET /get] miss, store')
-    logger.should_receive(:debug).with('HTTP Cache: [GET /get?q=what] miss, store')
+  it 'differs requests with different query strings in the log' do
+    expect(logger).to receive(:debug).with('HTTP Cache: [GET /get] miss, store')
+    expect(logger).to receive(:debug).with('HTTP Cache: [GET /get?q=what] miss, store')
     client.get('get')
-    client.get('get', :q => "what")
+    client.get('get', q: 'what')
   end
 
-  it "logs that a stored GET response is fresh" do
+  it 'logs that a stored GET response is fresh' do
     client.get('get')
-    logger.should_receive(:debug).with('HTTP Cache: [GET /get] fresh')
+    expect(logger).to receive(:debug).with('HTTP Cache: [GET /get] fresh')
     client.get('get')
   end
 
-  it "sends the 'Last-Modified' header on response validation" do
+  it 'sends the "Last-Modified" header on response validation' do
     client.get('timestamped')
-    client.get('timestamped').body.should == "1"
+    expect(client.get('timestamped').body).to eq('1')
   end
 
-  it "logs that the request with 'Last-Modified' was revalidated" do
+  it 'logs that the request with "Last-Modified" was revalidated' do
     client.get('timestamped')
-    logger.should_receive(:debug).with('HTTP Cache: [GET /timestamped] valid, store')
-    client.get('timestamped').body.should == "1"
+    expect(logger).to receive(:debug).with('HTTP Cache: [GET /timestamped] valid, store')
+    expect(client.get('timestamped').body).to eq('1')
   end
 
-  it "sends the 'If-None-Match' header on response validation" do
+  it 'sends the "If-None-Match" header on response validation' do
     client.get('etag')
-    client.get('etag').body.should == "1"
+    expect(client.get('etag').body).to eq('1')
   end
 
-  it "logs that the request with 'ETag' was revalidated" do
+  it 'logs that the request with "ETag" was revalidated' do
     client.get('etag')
-    logger.should_receive(:debug).with('HTTP Cache: [GET /etag] valid, store')
-    client.get('etag').body.should == "1"
+    expect(logger).to receive(:debug).with('HTTP Cache: [GET /etag] valid, store')
+    expect(client.get('etag').body).to eq('1')
   end
 
-  it "maintains the 'Date' header for cached responses" do
-    date = client.get('get').headers['Date']
-    client.get('get').headers['Date'].should == date
+  it 'maintains the "Date" header for cached responses' do
+    first_date = client.get('get').headers['Date']
+    second_date = client.get('get').headers['Date']
+    expect(first_date).to eq(second_date)
   end
 
-  it "preserves an old 'Date' header if present" do
+  it 'preserves an old "Date" header if present' do
     date = client.get('yesterday').headers['Date']
-    date.should =~ /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/
+    expect(date).to match(/^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/)
   end
 
-  it "updates the 'Cache-Control' header when a response is validated" do
-    cache_control = client.get('etag').headers['Cache-Control']
-    client.get('etag').headers['Cache-Control'].should_not == cache_control
+  it 'updates the "Cache-Control" header when a response is validated' do
+    first_cache_control  = client.get('etag').headers['Cache-Control']
+    second_cache_control = client.get('etag').headers['Cache-Control']
+    expect(first_cache_control).not_to eql(second_cache_control)
   end
 
-  it "updates the 'Date' header when a response is validated" do
-    date = client.get('etag').headers['Date']
-    client.get('etag').headers['Date'].should_not == date
+  it 'updates the "Date" header when a response is validated' do
+    first_date  = client.get('etag').headers['Date']
+    second_date = client.get('etag').headers['Date']
+    expect(first_date).not_to eql(second_date)
   end
 
-  it "updates the 'Expires' header when a response is validated" do
-    expires = client.get('etag').headers['Expires']
-    client.get('etag').headers['Expires'].should_not == expires
+  it 'updates the "Expires" header when a response is validated' do
+    first_expires  = client.get('etag').headers['Expires']
+    second_expires = client.get('etag').headers['Expires']
+    expect(first_expires).not_to eql(second_expires)
   end
-  
-  it "updates the 'Vary' header when a response is validated" do
-    vary = client.get('etag').headers['Vary']
-    client.get('etag').headers['Vary'].should_not == vary
+
+  it 'updates the "Vary" header when a response is validated' do
+    first_vary  = client.get('etag').headers['Vary']
+    second_vary = client.get('etag').headers['Vary']
+    expect(first_vary).not_to eql(second_vary)
   end
 
   describe 'Configuration options' do
-    let(:app) { double("it's an app!") }
+    let(:app) { double('it is an app!') }
 
     it 'uses the options to create a Cache Store' do
-      ActiveSupport::Cache.should_receive(:lookup_store).with(:file_store, ['tmp'])
-      Faraday::HttpCache.new(app, :file_store, 'tmp')
+      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:file_store, ['tmp'])
+      Faraday::HttpCache.new(app, store: :file_store, store_options: ['tmp'])
     end
 
     it 'accepts a Hash option' do
-      ActiveSupport::Cache.should_receive(:lookup_store).with(:memory_store, { :size => 1024 })
-      Faraday::HttpCache.new(app, :memory_store, :size => 1024)
+      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, [{ size: 1024 }])
+      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)
+      Faraday::HttpCache.new(app, store: :memory_store, logger: logger)
     end
 
-    it "consumes the 'logger' key" do
-      ActiveSupport::Cache.should_receive(:lookup_store).with(:memory_store, {})
-      Faraday::HttpCache.new(app, :memory_store, :logger => logger)
+    context 'with deprecated options format' do
+      it 'uses the options to create a Cache Store' do
+        expect(ActiveSupport::Cache).to receive(:lookup_store).with(:file_store, ['tmp'])
+        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 }])
+        Faraday::HttpCache.new(app, :memory_store, size: 1024)
+      end
+
+      it 'consumes the "logger" key' do
+        expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, [{}])
+        Faraday::HttpCache.new(app, :memory_store, logger: logger)
+      end
+
+      it 'warns the user about the deprecated options' do
+        expect(ActiveSupport::Deprecation).to receive(:warn)
+
+        Faraday::HttpCache.new(app, :memory_store, logger: logger)
+      end
     end
   end
 end

data/spec/response_spec.rb

@@ -1,156 +1,157 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Faraday::HttpCache::Response do
-  describe "cacheable?" do
-    it "the response isn't cacheable if the response is marked as private" do
-      headers  = { "Cache-Control" => "private" }
-      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+  describe 'cacheable?' do
+    it 'the response is not cacheable if the response is marked as private' do
+      headers  = { 'Cache-Control' => 'private' }
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
 
-      response.should_not be_cacheable
+      expect(response).not_to be_cacheable
     end
 
-    it "the response isn't cacheable if it shouldn't be stored" do
-      headers  = { "Cache-Control" => "no-store" }
-      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+    it 'the response is not cacheable if it should not be stored' do
+      headers  = { 'Cache-Control' => 'no-store' }
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
 
-      response.should_not be_cacheable
+      expect(response).not_to be_cacheable
     end
 
-    it "the response isn't cacheable when the status code isn't acceptable" do
-      headers  = { "Cache-Control" => "max-age=400" }
-      response = Faraday::HttpCache::Response.new(:status => 503, :response_headers => headers)
-      response.should_not be_cacheable
+    it 'the response is not cacheable when the status code is not acceptable' do
+      headers  = { 'Cache-Control' => 'max-age=400' }
+      response = Faraday::HttpCache::Response.new(status: 503, response_headers: headers)
+      expect(response).not_to be_cacheable
     end
 
     [200, 203, 300, 301, 302, 404, 410].each do |status|
       it "the response is cacheable if the status code is #{status} and the response is fresh" do
-        headers  = { "Cache-Control" => "max-age=400" }
-        response = Faraday::HttpCache::Response.new(:status => status, :response_headers => headers)
+        headers  = { 'Cache-Control' => 'max-age=400' }
+        response = Faraday::HttpCache::Response.new(status: status, response_headers: headers)
 
-        response.should be_cacheable
+        expect(response).to be_cacheable
       end
     end
   end
 
-  describe "freshness" do
-    it "is fresh if the response still has some time to live" do
+  describe 'freshness' do
+    it 'is fresh if the response still has some time to live' do
       date = 200.seconds.ago.httpdate
-      headers = { "Cache-Control" => "max-age=400", 'Date' => date }
-      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+      headers = { 'Cache-Control' => 'max-age=400', 'Date' => date }
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
 
-      response.should be_fresh
+      expect(response).to be_fresh
     end
 
-    it "isn't fresh when the ttl has expired" do
+    it 'is not fresh when the ttl has expired' do
       date = 500.seconds.ago.httpdate
-      headers = { "Cache-Control" => "max-age=400", 'Date' => date }
-      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+      headers = { 'Cache-Control' => 'max-age=400', 'Date' => date }
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
 
-      response.should_not be_fresh
+      expect(response).not_to be_fresh
     end
   end
 
-  it "sets the 'Date' header if isn't present" do
+  it 'sets the "Date" header if is not present' do
     headers = { 'Date' => nil }
-    response = Faraday::HttpCache::Response.new(:response_headers => headers)
+    response = Faraday::HttpCache::Response.new(response_headers: headers)
 
-    response.date.should be_present
+    expect(response.date).to be
   end
 
-  it "the response is not modified if the status code is 304" do
-    response = Faraday::HttpCache::Response.new(:status => 304)
-    response.should be_not_modified
+  it 'the response is not modified if the status code is 304' do
+    response = Faraday::HttpCache::Response.new(status: 304)
+    expect(response).to be_not_modified
   end
 
-  it "returns the 'Last-Modified' header on the #last_modified method" do
-    headers = { "Last-Modified" => "123"}
-    response = Faraday::HttpCache::Response.new(:response_headers => headers)
-    response.last_modified.should == "123"
+  it 'returns the "Last-Modified" header on the #last_modified method' do
+    headers = { 'Last-Modified' => '123' }
+    response = Faraday::HttpCache::Response.new(response_headers: headers)
+    expect(response.last_modified).to eq('123')
   end
 
-  it "returns the 'ETag' header on the #etag method" do
-    headers = { "ETag" => "tag"}
-    response = Faraday::HttpCache::Response.new(:response_headers => headers)
-    response.etag.should == "tag"
+  it 'returns the "ETag" header on the #etag method' do
+    headers = { 'ETag' => 'tag' }
+    response = Faraday::HttpCache::Response.new(response_headers: headers)
+    expect(response.etag).to eq('tag')
   end
 
-  describe "max age calculation" do
-    it "uses the shared max age directive when present" do
-      headers = { "Cache-Control" => "s-maxage=200, max-age=0"}
-      response = Faraday::HttpCache::Response.new(:response_headers => headers)
-      response.max_age.should == 200
+  describe 'max age calculation' do
+    it 'uses the shared max age directive when present' do
+      headers = { 'Cache-Control' => 's-maxage=200, max-age=0' }
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
+      expect(response.max_age).to be(200)
     end
 
-    it "uses the max age directive when present" do
-      headers = { "Cache-Control" => "max-age=200"}
-      response = Faraday::HttpCache::Response.new(:response_headers => headers)
-      response.max_age.should == 200
+    it 'uses the max age directive when present' do
+      headers = { 'Cache-Control' => 'max-age=200' }
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
+      expect(response.max_age).to be(200)
     end
 
-    it "fallsback to the expiration date leftovers" do
-      headers = { "Expires" => (Time.now + 100).httpdate, 'Date' => Time.now.httpdate }
-      response = Faraday::HttpCache::Response.new(:response_headers => headers)
-      response.max_age.should < 100
-      response.max_age.should > 98
+    it 'fallsback to the expiration date leftovers' do
+      headers = { 'Expires' => (Time.now + 100).httpdate, 'Date' => Time.now.httpdate }
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
+
+      expect(response.max_age).to be < 100
+      expect(response.max_age).to be > 98
     end
 
-    it "returns nil when there's no information to calculate the max age" do
+    it 'returns nil when there is no information to calculate the max age' do
       response = Faraday::HttpCache::Response.new
-      response.max_age.should be_nil
+      expect(response.max_age).to be_nil
     end
   end
 
-  describe "age calculation" do
-    it "uses the 'Age' header if it's present" do
-      response = Faraday::HttpCache::Response.new(:response_headers => { "Age" => "3" })
-      response.age.should == 3
+  describe 'age calculation' do
+    it 'uses the "Age" header if it is present' do
+      response = Faraday::HttpCache::Response.new(response_headers: { 'Age' => '3' })
+      expect(response.age).to eq(3)
     end
 
-    it "calculates the time from the 'Date' header" do
+    it 'calculates the time from the "Date" header' do
       date = 3.seconds.ago.httpdate
-      response = Faraday::HttpCache::Response.new(:response_headers => { 'Date' => date })
-      response.age.should == 3
+      response = Faraday::HttpCache::Response.new(response_headers: { 'Date' => date })
+      expect(response.age).to eq(3)
     end
 
-    it "returns 0 if there's no 'Age' or 'Date' header present" do
-      response = Faraday::HttpCache::Response.new(:response_headers => {})
-      response.age.should == 0
+    it 'returns 0 if there is no "Age" or "Date" header present' do
+      response = Faraday::HttpCache::Response.new(response_headers: {})
+      expect(response.age).to eq(0)
     end
   end
 
-  describe "time to live calculation" do
-    it "returns the time to live based on the max age limit" do
+  describe 'time to live calculation' do
+    it 'returns the time to live based on the max age limit' do
       date = 200.seconds.ago.httpdate
-      headers = { "Cache-Control" => "max-age=400", 'Date' => date }
-      response = Faraday::HttpCache::Response.new(:response_headers => headers)
-      response.ttl.should == 200
+      headers = { 'Cache-Control' => 'max-age=400', 'Date' => date }
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
+      expect(response.ttl).to eq(200)
     end
   end
 
-  describe "response unboxing" do
-    subject { described_class.new(:status => 200, :response_headers => {}, :body => "Hi!") }
+  describe 'response unboxing' do
+    subject { described_class.new(status: 200, response_headers: {}, body: 'Hi!') }
 
-    let(:env) { { :method => :get } }
+    let(:env) { { method: :get } }
     let(:response) { subject.to_response(env) }
 
-    it "merges the supplied env object with the response data" do
-      response.env[:method].should be
+    it 'merges the supplied env object with the response data' do
+      expect(response.env[:method]).to be
     end
 
-    it "returns a Faraday::Response" do
-      response.should be_a Faraday::Response
+    it 'returns a Faraday::Response' do
+      expect(response).to be_a(Faraday::Response)
     end
 
-    it "merges the status code" do
-      response.status.should == 200
+    it 'merges the status code' do
+      expect(response.status).to eq(200)
     end
 
-    it "merges the headers" do
-      response.headers.should be_a Faraday::Utils::Headers
+    it 'merges the headers' do
+      expect(response.headers).to be_a(Faraday::Utils::Headers)
     end
 
-    it "merges the body" do
-      response.body.should == "Hi!"
+    it 'merges the body' do
+      expect(response.body).to eq('Hi!')
     end
   end
 
@@ -163,13 +164,12 @@ describe Faraday::HttpCache::Response do
           'Expires' => 37.seconds.from_now.httpdate,
           'Last-Modified' => 300.seconds.ago.httpdate
       }
-      response = Faraday::HttpCache::Response.new(:response_headers => headers)
-      response.should be_fresh
+      response = Faraday::HttpCache::Response.new(response_headers: headers)
+      expect(response).to be_fresh
 
       response.serializable_hash
-      response.max_age.should == 34
-      response.should_not be_fresh
+      expect(response.max_age).to eq(34)
+      expect(response).not_to be_fresh
     end
   end
-
 end