agiley-faraday_middleware 0.8.3.2 → 0.9.0

data/lib/faraday_middleware/response/mashify.rb

@@ -1,7 +1,11 @@
 require 'faraday'
 
 module FaradayMiddleware
+  # Public: Converts parsed response bodies to a Hashie::Mash if they were of
+  # Hash or Array type.
   class Mashify < Faraday::Response::Middleware
+    attr_accessor :mash_class
+
     class << self
       attr_accessor :mash_class
     end
@@ -11,12 +15,17 @@ module FaradayMiddleware
       self.mash_class = ::Hashie::Mash
     end
 
+    def initialize(app = nil, options = {})
+      super(app)
+      self.mash_class = options[:mash_class] || self.class.mash_class
+    end
+
     def parse(body)
       case body
       when Hash
-        self.class.mash_class.new(body)
+        mash_class.new(body)
       when Array
-        body.map { |item| item.is_a?(Hash) ? self.class.mash_class.new(item) : item }
+        body.map { |item| parse(item) }
       else
         body
       end

data/lib/faraday_middleware/response/parse_dates.rb

@@ -0,0 +1,39 @@
+require "time"
+require "faraday"
+
+module FaradayMiddleware
+  # Parse dates from response body
+  class ParseDates < ::Faraday::Response::Middleware
+    ISO_DATE_FORMAT = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\Z/m
+
+    def initialize(app, options = {})
+      @regexp = options[:match] || ISO_DATE_FORMAT
+      super(app)
+    end
+
+    def call(env)
+      response = @app.call(env)
+      parse_dates! response.env[:body]
+      response
+    end
+
+    private
+
+    def parse_dates!(value)
+      case value
+      when Hash
+        value.each do |key, element|
+          value[key] = parse_dates!(element)
+        end
+      when Array
+        value.each_with_index do |element, index|
+          value[index] = parse_dates!(element)
+        end
+      when @regexp
+        Time.parse(value)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/faraday_middleware/response/parse_json.rb

@@ -3,11 +3,13 @@ require 'faraday_middleware/response_middleware'
 module FaradayMiddleware
   # Public: Parse response bodies as JSON.
   class ParseJson < ResponseMiddleware
-    dependency 'json'
+    dependency do
+      require 'json' unless defined?(::JSON)
+    end
 
-    define_parser { |body|
-      JSON.parse body unless body.empty?
-    }
+    define_parser do |body|
+      ::JSON.parse body unless body.strip.empty?
+    end
 
     # Public: Override the content-type of the response with "application/json"
     # if the response body looks like it might be JSON, i.e. starts with an
@@ -26,9 +28,19 @@ module FaradayMiddleware
       end
 
       BRACKETS = %w- [ { -
+      WHITESPACE = [ " ", "\n", "\r", "\t" ]
 
       def parse_response?(env)
-        super and BRACKETS.include? env[:body][0,1]
+        super and BRACKETS.include? first_char(env[:body])
+      end
+
+      def first_char(body)
+        idx = -1
+        begin
+          char = body[idx += 1]
+          char = char.chr if char
+        end while char and WHITESPACE.include? char
+        char
       end
     end
   end

data/lib/faraday_middleware/response/parse_marshal.rb

@@ -3,9 +3,9 @@ require 'faraday_middleware/response_middleware'
 module FaradayMiddleware
   # Public: Restore marshalled Ruby objects in response bodies.
   class ParseMarshal < ResponseMiddleware
-    define_parser { |body|
+    define_parser do |body|
       ::Marshal.load body unless body.empty?
-    }
+    end
   end
 end
 

data/lib/faraday_middleware/response/parse_xml.rb

@@ -1,12 +1,13 @@
 require 'faraday_middleware/response_middleware'
 
 module FaradayMiddleware
+  # Public: parses response bodies with MultiXml.
   class ParseXml < ResponseMiddleware
     dependency 'multi_xml'
 
-    define_parser { |body|
+    define_parser do |body|
       ::MultiXml.parse(body)
-    }
+    end
   end
 end
 

data/lib/faraday_middleware/response/parse_yaml.rb

@@ -5,7 +5,9 @@ module FaradayMiddleware
   class ParseYaml < ResponseMiddleware
     dependency 'yaml'
 
-    define_parser { |body| ::YAML.load body }
+    define_parser do |body|
+      ::YAML.load body
+    end
   end
 end
 

data/lib/faraday_middleware/response/rashify.rb

@@ -1,6 +1,8 @@
 require 'faraday_middleware/response/mashify'
 
 module FaradayMiddleware
+  # Public: Converts parsed response bodies to a Hashie::Rash if they were of
+  # Hash or Array type.
   class Rashify < Mashify
     dependency do
       require 'rash'

data/lib/faraday_middleware/response_middleware.rb

@@ -26,8 +26,8 @@ module FaradayMiddleware
       @content_types = Array(options[:content_type])
     end
 
-    def call(env)
-      @app.call(env).on_complete do
+    def call(environment)
+      @app.call(environment).on_complete do |env|
         if process_response_type?(response_type(env)) and parse_response?(env)
           process_response(env)
         end

data/lib/faraday_middleware/version.rb

@@ -1,3 +1,3 @@
 module FaradayMiddleware
-  VERSION = "0.8.3.2"
+  VERSION = "0.9.0"
 end

data/spec/caching_test.rb

@@ -2,6 +2,7 @@ require 'test/unit'
 require 'forwardable'
 require 'fileutils'
 require 'rack/cache'
+require 'faraday'
 require 'faraday_middleware/response/caching'
 require 'faraday_middleware/rack_compatible'
 
@@ -22,6 +23,16 @@ class CachingTest < Test::Unit::TestCase
     end
   end
 
+  class Lint < Struct.new(:app)
+    def call(env)
+      app.call(env).on_complete do
+        raise "no headers" unless env[:response_headers].is_a? Hash
+        raise "no response" unless env[:response].is_a? Faraday::Response
+        raise "env not identical" unless env[:response].env.object_id == env.object_id
+      end
+    end
+  end
+
   def setup
     @cache = TestCache.new
 
@@ -31,6 +42,7 @@ class CachingTest < Test::Unit::TestCase
     }
 
     @conn = Faraday.new do |b|
+      b.use Lint
       b.use FaradayMiddleware::Caching, @cache
       b.adapter :test do |stub|
         stub.get('/', &response)
@@ -55,7 +67,7 @@ class CachingTest < Test::Unit::TestCase
     get('/') # make cache
     response = get('/')
     assert_equal :get, response.env[:method]
-    assert_equal '/', response.env[:url].to_s
+    assert_equal '/', response.env[:url].request_uri
   end
 
   def test_cache_query_params
@@ -76,10 +88,22 @@ end
 class HttpCachingTest < Test::Unit::TestCase
   include FileUtils
 
-  CACHE_DIR = File.expand_path('../cache', __FILE__)
+  CACHE_DIR = File.expand_path('../../tmp/cache', __FILE__)
+
+  # middleware to check whether "rack.errors" is free of error reports
+  class RackErrorsComplainer < Struct.new(:app)
+    def call(env)
+      response = app.call(env)
+      error_stream = env['rack.errors'].string
+      raise %(unexpected error in 'rack.errors') if error_stream.include? 'error'
+      response
+    end
+  end
 
   def setup
     rm_r CACHE_DIR if File.exists? CACHE_DIR
+    # force reinitializing cache dirs
+    Rack::Cache::Storage.instance.clear
 
     request_count = 0
     response = lambda { |env|
@@ -90,6 +114,8 @@ class HttpCachingTest < Test::Unit::TestCase
     }
 
     @conn = Faraday.new do |b|
+      b.use RackErrorsComplainer
+
       b.use FaradayMiddleware::RackCompatible, Rack::Cache::Context,
         :metastore   => "file:#{CACHE_DIR}/rack/meta",
         :entitystore => "file:#{CACHE_DIR}/rack/body",
@@ -106,10 +132,17 @@ class HttpCachingTest < Test::Unit::TestCase
   def_delegators :@conn, :get, :post
 
   def test_cache_get
-    assert_equal 'request:1', get('/', :user_agent => 'test').body
+    response = get('/', :user_agent => 'test')
+    assert_equal 'request:1', response.body
+    assert_equal :get, response.env[:method]
+    assert_equal 200, response.status
+
     response = get('/', :user_agent => 'test')
     assert_equal 'request:1', response.body
     assert_equal 'text/plain', response['content-type']
+    assert_equal :get, response.env[:method]
+    assert response.env[:request].respond_to?(:fetch)
+    assert_equal 200, response.status
 
     assert_equal 'request:2', post('/').body
   end
@@ -119,4 +152,4 @@ class HttpCachingTest < Test::Unit::TestCase
     assert_equal 'request:2', post('/').body
     assert_equal 'request:3', post('/').body
   end
-end unless defined? RUBY_ENGINE and "rbx" == RUBY_ENGINE  # rbx bug #1522
+end unless defined? RUBY_ENGINE and "rbx" == RUBY_ENGINE # rbx bug #1522

data/spec/chunked_spec.rb

@@ -0,0 +1,78 @@
+require 'helper'
+require 'faraday_middleware/response/chunked'
+
+describe FaradayMiddleware::Chunked, :type => :response do
+  context "no transfer-encoding" do
+    it "doesn't change nil body" do
+      expect(process(nil).body).to be_nil
+    end
+
+    it "doesn't change an empty body" do
+      expect(process('').body).to eq('')
+    end
+
+    it "doesn't change a normal body" do
+      expect(process('asdf').body).to eq('asdf')
+    end
+  end
+
+  context "transfer-encoding gzip" do
+    let(:headers) { {"transfer-encoding" => "gzip"}}
+
+    it "doesn't change nil body" do
+      expect(process(nil).body).to be_nil
+    end
+
+    it "doesn't change an empty body" do
+      expect(process('').body).to eq('')
+    end
+
+    it "doesn't change a normal body" do
+      expect(process('asdf').body).to eq('asdf')
+    end
+  end
+
+  context "transfer-encoding chunked" do
+    let(:headers) { {"transfer-encoding" => "chunked"}}
+
+    it "doesn't change nil body" do
+      expect(process(nil).body).to be_nil
+    end
+
+    it "doesn't change an empty body" do
+      expect(process('').body).to eq('')
+    end
+
+    it "parses a basic chunked body" do
+      expect(process("10\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
+    end
+
+    it "parses a chunked body with no ending chunk" do
+      expect(process("10\r\nasdfghjklasdfghj\r\n").body).to eq('asdfghjklasdfghj')
+    end
+
+    it "parses a chunked body with no trailing CRLF on the data chunk" do
+      expect(process("10\r\nasdfghjklasdfghj0\r\n").body).to eq('asdfghjklasdfghj')
+    end
+
+    it "parses a chunked body with an extension" do
+      expect(process("10;foo=bar\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
+    end
+
+    it "parses a chunked body with two extensions" do
+      expect(process("10;foo=bar;bar=baz\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
+    end
+
+    it "parses a chunked body with two chunks" do
+      expect(process("8\r\nasdfghjk\r\n8\r\nlasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
+    end
+  end
+
+  context "transfer-encoding chunked,chunked" do
+    let(:headers) { {"transfer-encoding" => "chunked,chunked"}}
+
+    it "parses a basic chunked body" do
+      expect(process("10\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
+    end
+  end
+end

data/spec/encode_json_spec.rb

@@ -17,11 +17,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process(nil) }
 
     it "doesn't change body" do
-      result_body.should be_nil
+      expect(result_body).to be_nil
     end
 
     it "doesn't add content type" do
-      result_type.should be_nil
+      expect(result_type).to be_nil
     end
   end
 
@@ -29,11 +29,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process('') }
 
     it "doesn't change body" do
-      result_body.should be_empty
+      expect(result_body).to be_empty
     end
 
     it "doesn't add content type" do
-      result_type.should be_nil
+      expect(result_type).to be_nil
     end
   end
 
@@ -41,11 +41,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process('{"a":1}') }
 
     it "doesn't change body" do
-      result_body.should eql('{"a":1}')
+      expect(result_body).to eq('{"a":1}')
     end
 
     it "adds content type" do
-      result_type.should eql('application/json')
+      expect(result_type).to eq('application/json')
     end
   end
 
@@ -53,11 +53,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process({:a => 1}) }
 
     it "encodes body" do
-      result_body.should eql('{"a":1}')
+      expect(result_body).to eq('{"a":1}')
     end
 
     it "adds content type" do
-      result_type.should eql('application/json')
+      expect(result_type).to eq('application/json')
     end
   end
 
@@ -65,7 +65,7 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process({}) }
 
     it "encodes body" do
-      result_body.should eql('{}')
+      expect(result_body).to eq('{}')
     end
   end
 
@@ -73,11 +73,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process({:a => 1}, 'application/json; charset=utf-8') }
 
     it "encodes body" do
-      result_body.should eql('{"a":1}')
+      expect(result_body).to eq('{"a":1}')
     end
 
     it "doesn't change content type" do
-      result_type.should eql('application/json; charset=utf-8')
+      expect(result_type).to eq('application/json; charset=utf-8')
     end
   end
 
@@ -85,11 +85,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process({:a => 1}, 'application/xml; charset=utf-8') }
 
     it "doesn't change body" do
-      result_body.should eql({:a => 1})
+      expect(result_body).to eq({:a => 1})
     end
 
     it "doesn't change content type" do
-      result_type.should eql('application/xml; charset=utf-8')
+      expect(result_type).to eq('application/xml; charset=utf-8')
     end
   end
 end

data/spec/follow_redirects_spec.rb

@@ -1,33 +1,218 @@
 require 'helper'
 require 'faraday_middleware/response/follow_redirects'
 require 'faraday'
-require 'forwardable'
+
+# expose a method in Test adapter that should have been public
+Faraday::Adapter::Test::Stubs.class_eval { public :new_stub }
 
 describe FaradayMiddleware::FollowRedirects do
-  let(:connection) {
-    Faraday.new do |c|
-      c.use described_class
-      c.adapter :test do |stub|
-        stub.get('/')        { [301, {'Location' => '/found'}, ''] }
-        stub.post('/create') { [302, {'Location' => '/'}, ''] }
-        stub.get('/found')   { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-        stub.get('/loop')    { [302, {'Location' => '/loop'}, ''] }
+  let(:middleware_options) { Hash.new }
+
+  shared_examples_for "a successful redirection" do |status_code|
+    it "follows the redirection for a GET request" do
+      expect(connection do |stub|
+        stub.get('/permanent') { [status_code, {'Location' => '/found'}, ''] }
+        stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+      end.get('/permanent').body).to eq 'fin'
+    end
+
+    it "follows the redirection for a HEAD request" do
+      expect(connection do |stub|
+               stub.head('/permanent') { [status_code, {'Location' => '/found'}, ''] }
+               stub.head('/found') { [200, {'Content-Type' => 'text/plain'}, ''] }
+             end.head('/permanent').status).to eq 200
+    end
+
+    it "follows the redirection for a OPTIONS request" do
+      expect(connection do |stub|
+               stub.new_stub(:options, '/permanent') { [status_code, {'Location' => '/found'}, ''] }
+               stub.new_stub(:options, '/found') { [200, {'Content-Type' => 'text/plain'}, ''] }
+             end.run_request(:options, '/permanent', nil, nil).status).to eq 200
+    end
+  end
+
+  shared_examples_for "a forced GET redirection" do |status_code|
+    [:put, :post, :delete, :patch].each do |method|
+      it "a #{method.to_s.upcase} request is converted to a GET" do
+        expect(connection do |stub|
+          stub.new_stub(method, '/redirect') {
+            [status_code, {'Location' => '/found'}, 'elsewhere']
+          }
+          stub.get('/found') { |env|
+            body = env[:body] and body.empty? && (body = nil)
+            [200, {'Content-Type' => 'text/plain'}, body.inspect]
+          }
+        end.run_request(method, '/redirect', 'request data', nil).body).to eq('nil')
+      end
+    end
+  end
+
+  shared_examples_for "a replayed redirection" do |status_code|
+    it "redirects with the original request headers" do
+      conn = connection do |stub|
+        stub.get('/redirect') {
+          [status_code, {'Location' => '/found'}, '']
+        }
+        stub.get('/found') { |env|
+          [200, {'Content-Type' => 'text/plain'}, env[:request_headers]['X-Test-Value']]
+        }
+      end
+
+      response = conn.get('/redirect') { |req|
+        req.headers['X-Test-Value'] = 'success'
+      }
+
+      expect(response.body).to eq('success')
+    end
+
+    [:put, :post, :delete, :patch].each do |method|
+      it "replays a #{method.to_s.upcase} request" do
+        expect(connection do |stub|
+          stub.new_stub(method, '/redirect') { [status_code, {'Location' => '/found'}, ''] }
+          stub.new_stub(method, '/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+        end.run_request(method, '/redirect', nil, nil).body).to eq 'fin'
       end
     end
-  }
 
-  extend Forwardable
-  def_delegators :connection, :get, :post
+    [:put, :post, :patch].each do |method|
+      it "forwards request body for a #{method.to_s.upcase} request" do
+        conn = connection do |stub|
+          stub.new_stub(method, '/redirect') {
+            [status_code, {'Location' => '/found'}, '']
+          }
+          stub.new_stub(method, '/found') { |env|
+            [200, {'Content-Type' => 'text/plain'}, env[:body]]
+          }
+        end
 
-  it "follows redirect" do
-    get('/').body.should eql('fin')
+        response = conn.run_request(method, '/redirect', 'original data', nil)
+        expect(response.body).to eq('original data')
+      end
+    end
   end
 
-  it "follows redirect twice" do
-    post('/create').body.should eql('fin')
+
+  it "returns non-redirect response results" do
+    expect(connection do |stub|
+      stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+    end.get('/found').body).to eq 'fin'
+  end
+
+  it "follows a single redirection" do
+    expect(connection do |stub|
+      stub.get('/')      { [301, {'Location' => '/found'}, ''] }
+      stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+    end.get('/').body).to eq 'fin'
   end
 
-  it "raises exception on loop" do
-    expect { get('/loop') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
+  it "follows many redirections" do
+    expect(connection do |stub|
+      stub.get('/')          { [301, {'Location' => '/redirect1'}, ''] }
+      stub.get('/redirect1') { [301, {'Location' => '/redirect2'}, ''] }
+      stub.get('/redirect2') { [301, {'Location' => '/found'}, ''] }
+      stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+    end.get('/').body).to eq 'fin'
+  end
+
+  it "raises a FaradayMiddleware::RedirectLimitReached after 3 redirections (by default)" do
+    conn = connection do |stub|
+      stub.get('/')          { [301, {'Location' => '/redirect1'}, ''] }
+      stub.get('/redirect1') { [301, {'Location' => '/redirect2'}, ''] }
+      stub.get('/redirect2') { [301, {'Location' => '/redirect3'}, ''] }
+      stub.get('/redirect3') { [301, {'Location' => '/found'}, ''] }
+      stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+    end
+
+    expect{ conn.get('/') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
+  end
+
+  it "raises a FaradayMiddleware::RedirectLimitReached after the initialized limit" do
+    conn = connection(:limit => 1) do |stub|
+      stub.get('/')          { [301, {'Location' => '/redirect1'}, ''] }
+      stub.get('/redirect1') { [301, {'Location' => '/found'}, ''] }
+      stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+    end
+
+    expect{ conn.get('/') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
+  end
+
+  context "when cookies option" do
+
+    let(:cookies) { 'cookie1=abcdefg; cookie2=1234567; cookie3=awesome' }
+
+    context "is :all" do
+      it "puts all cookies from the response into the next request" do
+        expect(connection(:cookies => :all) do |stub|
+          stub.get('/')           { [301, {'Location' => '/found', 'Cookies' => cookies }, ''] }
+          stub.get('/found')      { [200, {'Content-Type' => 'text/plain'}, ''] }
+        end.get('/').env[:request_headers][:cookies]).to eq(cookies)
+      end
+
+      it "not set cookies header on request when response has no cookies" do
+        expect(connection(:cookies => :all) do |stub|
+          stub.get('/')           { [301, {'Location' => '/found'}, ''] }
+          stub.get('/found')      { [200, {'Content-Type' => 'text/plain'}, ''] }
+        end.get('/').env[:request_headers].has_key?('Cookies')).to eq(false)
+      end
+    end
+
+    context "is an array of cookie names" do
+      it "puts selected cookies from the response into the next request" do
+        expect(connection(:cookies => ['cookie2']) do |stub|
+          stub.get('/')           { [301, {'Location' => '/found', 'Cookies' => cookies }, ''] }
+          stub.get('/found')      { [200, {'Content-Type' => 'text/plain'}, ''] }
+        end.get('/').env[:request_headers][:cookies]).to eq('cookie2=1234567')
+      end
+    end
+  end
+
+  context "for an HTTP 301 response" do
+    it_behaves_like 'a successful redirection', 301
+    it_behaves_like 'a forced GET redirection', 301
+  end
+
+  context "for an HTTP 302 response" do
+    it_behaves_like 'a successful redirection', 302
+
+    context "by default" do
+      it_behaves_like 'a forced GET redirection', 302
+    end
+
+    context "with standards compliancy enabled" do
+      let(:middleware_options) { { :standards_compliant => true } }
+      it_behaves_like 'a replayed redirection', 302
+    end
+  end
+
+  context "for an HTTP 303 response" do
+    it_behaves_like 'a successful redirection', 303
+    it_behaves_like 'a forced GET redirection', 303
+  end
+
+  context "for an HTTP 307 response" do
+    it_behaves_like 'a successful redirection', 307
+    it_behaves_like 'a replayed redirection', 307
+  end
+
+  # checks env hash in request phase for basic validity
+  class Lint < Struct.new(:app)
+    def call(env)
+      if env[:status] or env[:response] or env[:response_headers]
+        raise "invalid request: #{env.inspect}"
+      end
+      app.call(env)
+    end
+  end
+
+  private
+
+  def connection(options = middleware_options)
+    Faraday.new do |c|
+      c.use described_class, options
+      c.use Lint
+      c.adapter :test do |stub|
+        yield(stub) if block_given?
+      end
+    end
   end
 end