agiley-faraday_middleware 0.8.3.2 → 0.9.0

data/spec/helper.rb

@@ -1,5 +1,15 @@
 if ENV['COVERAGE']
   require 'simplecov'
+
+  SimpleCov.formatter = Class.new do
+    def format(result)
+      SimpleCov::Formatter::HTMLFormatter.new.format(result) unless ENV['CI']
+      File.open('coverage/covered_percent', 'w') do |f|
+        f.puts result.source_files.covered_percent.to_i
+      end
+    end
+  end
+
   SimpleCov.start do
     # add_filter 'faraday_middleware.rb'
     add_filter 'backwards_compatibility.rb'
@@ -11,6 +21,7 @@ require 'rspec'
 module ResponseMiddlewareExampleGroup
   def self.included(base)
     base.let(:options) { Hash.new }
+    base.let(:headers) { Hash.new }
     base.let(:middleware) {
       described_class.new(lambda {|env|
         Faraday::Response.new(env)
@@ -21,7 +32,7 @@ module ResponseMiddlewareExampleGroup
   def process(body, content_type = nil, options = {})
     env = {
       :body => body, :request => options,
-      :response_headers => Faraday::Utils::Headers.new
+      :response_headers => Faraday::Utils::Headers.new(headers)
     }
     env[:response_headers]['content-type'] = content_type if content_type
     middleware.call(env)
@@ -30,4 +41,7 @@ end
 
 RSpec.configure do |config|
   config.include ResponseMiddlewareExampleGroup, :type => :response
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
 end

data/spec/mashify_spec.rb

@@ -2,63 +2,80 @@ require 'helper'
 require 'faraday_middleware/response/mashify'
 
 describe FaradayMiddleware::Mashify do
-  context 'during configuration' do
-    it 'should allow for a custom Mash class to be set' do
-      described_class.should respond_to(:mash_class)
-      described_class.should respond_to(:mash_class=)
+  context "during configuration" do
+    it "allows for a custom Mash class to be set" do
+      expect(described_class).to respond_to(:mash_class)
+      expect(described_class).to respond_to(:mash_class=)
     end
   end
 
-  context 'when used' do
+  context "when used" do
     before(:each) { described_class.mash_class = ::Hashie::Mash }
     let(:mashify) { described_class.new }
 
-    it 'should create a Hashie::Mash from the body' do
+    it "creates a Hashie::Mash from the body" do
       env = { :body => { "name" => "Erik Michaels-Ober", "username" => "sferik" } }
       me  = mashify.on_complete(env)
-      me.class.should == Hashie::Mash
+      expect(me.class).to eq(Hashie::Mash)
     end
 
-    it 'should handle strings' do
+    it "handles strings" do
       env = { :body => "Most amazing string EVER" }
       me  = mashify.on_complete(env)
-      me.should == "Most amazing string EVER"
+      expect(me).to eq("Most amazing string EVER")
     end
 
-    it 'should handle arrays' do
+    it "handles arrays" do
       env = { :body => [123, 456] }
       values = mashify.on_complete(env)
-      values.first.should == 123
-      values.last.should == 456
+      expect(values.first).to eq(123)
+      expect(values.last).to eq(456)
     end
 
-    it 'should handle arrays of hashes' do
+    it "handles arrays of hashes" do
       env = { :body => [{ "username" => "sferik" }, { "username" => "pengwynn" }] }
       us  = mashify.on_complete(env)
-      us.first.username.should == 'sferik'
-      us.last.username.should == 'pengwynn'
+      expect(us.first.username).to eq('sferik')
+      expect(us.last.username).to eq('pengwynn')
     end
 
-    it 'should handle mixed arrays' do
+    it "handles nested arrays of hashes" do
+      env = { :body => [[{ "username" => "sferik" }, { "username" => "pengwynn" }]] }
+      us  = mashify.on_complete(env)
+      expect(us.first.first.username).to eq('sferik')
+      expect(us.first.last.username).to eq('pengwynn')
+    end
+
+    it "handles mixed arrays" do
       env = { :body => [123, { "username" => "sferik" }, 456] }
       values = mashify.on_complete(env)
-      values.first.should == 123
-      values.last.should == 456
-      values[1].username.should == 'sferik'
+      expect(values.first).to eq(123)
+      expect(values.last).to eq(456)
+      expect(values[1].username).to eq('sferik')
     end
 
-    it 'should allow for use of custom Mash subclasses' do
+    it "allows for use of custom Mash subclasses at the class level" do
       class MyMash < ::Hashie::Mash; end
       described_class.mash_class = MyMash
 
       env = { :body => { "name" => "Erik Michaels-Ober", "username" => "sferik" } }
       me  = mashify.on_complete(env)
 
-      me.class.should == MyMash
+      expect(me.class).to eq(MyMash)
+    end
+
+    it "allows for use of custom Mash subclasses at the instance level" do
+      class MyMash < ::Hashie::Mash; end
+      mashify = described_class.new(nil, :mash_class => MyMash)
+
+      env = { :body => { "name" => "Erik Michaels-Ober", "username" => "sferik" } }
+      me  = mashify.on_complete(env)
+
+      expect(me.class).to eq(MyMash)
     end
   end
 
-  context 'integration test' do
+  context "integration test" do
     let(:stubs) { Faraday::Adapter::Test::Stubs.new }
     let(:connection) do
       Faraday::Connection.new do |builder|
@@ -69,11 +86,14 @@ describe FaradayMiddleware::Mashify do
 
     # although it is not good practice to pass a hash as the body, if we add ParseJson
     # to the middleware stack we end up testing two middlewares instead of one
-    it 'should create a Hash from the body' do
-      stubs.get('/hash') {[200, {'content-type' => 'application/json; charset=utf-8'}, { "name" => "Erik Michaels-Ober", "username" => "sferik" }]}
+    it "creates a Hash from the body" do
+      stubs.get('/hash') {
+        data = { 'name' => 'Erik Michaels-Ober', 'username' => 'sferik' }
+        [200, {'content-type' => 'application/json; charset=utf-8'}, data]
+      }
       me = connection.get('/hash').body
-      me.name.should == 'Erik Michaels-Ober'
-      me.username.should == 'sferik'
+      expect(me.name).to eq('Erik Michaels-Ober')
+      expect(me.username).to eq('sferik')
     end
   end
 end

data/spec/method_override_spec.rb

@@ -0,0 +1,92 @@
+require 'helper'
+require 'faraday_middleware/request/method_override'
+
+describe FaradayMiddleware::MethodOverride do
+
+  let(:middleware) { described_class.new(lambda {|env| env }, *options) }
+  let(:env) { middleware.call request_env(request_method) }
+
+  def request_env(method)
+    { :method => method,
+      :request_headers => Faraday::Utils::Headers.new
+    }
+  end
+
+  shared_examples "overrides method" do |method|
+    it "sets physical method to POST" do
+      expect(env[:method]).to eq(:post)
+    end
+
+    it "sets header to #{method}" do
+      expect(env[:request_headers]['X-Http-Method-Override']).to eq(method)
+    end
+  end
+
+  shared_examples "doesn't override method" do |method|
+    it "keeps original method" do
+      expect(env[:method]).to eq(method)
+    end
+
+    it "doesn't set header value" do
+      expect(env[:request_headers]).not_to have_key('X-Http-Method-Override')
+    end
+
+  end
+
+  context "with default options" do
+    let(:options) { nil }
+
+    context "GET" do
+      let(:request_method) { :get }
+      include_examples "doesn't override method", :get
+    end
+
+    context "POST" do
+      let(:request_method) { :post }
+      include_examples "doesn't override method", :post
+    end
+
+    context "PUT" do
+      let(:request_method) { :put }
+      include_examples "overrides method", 'PUT'
+    end
+  end
+
+  context "configured to rewrite [:patch, :delete]" do
+    let(:options) { [{ :rewrite => [:patch, :delete] }] }
+
+    context "PUT" do
+      let(:request_method) { :put }
+      include_examples "doesn't override method", :put
+    end
+
+    context "PATCH" do
+      let(:request_method) { :patch }
+      include_examples "overrides method", 'PATCH'
+    end
+
+    context "DELETE" do
+      let(:request_method) { :delete }
+      include_examples "overrides method", 'DELETE'
+    end
+  end
+
+  context "configured to rewrite ['PATCH']" do
+    let(:options) { [{ :rewrite => %w[PATCH] }] }
+
+    context "PATCH" do
+      let(:request_method) { :patch }
+      include_examples "overrides method", 'PATCH'
+    end
+  end
+
+  context "with invalid option" do
+    let(:options) { [{ :hello => 'world' }] }
+    let(:request_method) { :get }
+
+    it "raises key error" do
+      expect{ env }.to raise_error(IndexError, /key not found/)
+    end
+  end
+
+end

data/spec/oauth2_spec.rb

@@ -31,17 +31,17 @@ describe FaradayMiddleware::OAuth2 do
 
     it "doesn't add params" do
       request = perform(:q => 'hello')
-      query_params(request).should eq('q' => 'hello')
+      expect(query_params(request)).to eq('q' => 'hello')
     end
 
     it "doesn't add headers" do
-      auth_header(perform).should be_nil
+      expect(auth_header(perform)).to be_nil
     end
 
     it "creates header for explicit token" do
       request = perform(:q => 'hello', :access_token => 'abc123')
-      query_params(request).should eq('q' => 'hello', 'access_token' => 'abc123')
-      auth_header(request).should eq(%(Token token="abc123"))
+      expect(query_params(request)).to eq('q' => 'hello', 'access_token' => 'abc123')
+      expect(auth_header(request)).to eq(%(Token token="abc123"))
     end
   end
 
@@ -49,23 +49,23 @@ describe FaradayMiddleware::OAuth2 do
     let(:options) { 'XYZ' }
 
     it "adds token param" do
-      query_params(perform(:q => 'hello')).should eq('q' => 'hello', 'access_token' => 'XYZ')
+      expect(query_params(perform(:q => 'hello'))).to eq('q' => 'hello', 'access_token' => 'XYZ')
     end
 
     it "adds token header" do
-      auth_header(perform).should eq(%(Token token="XYZ"))
+      expect(auth_header(perform)).to eq(%(Token token="XYZ"))
     end
 
     it "overrides default with explicit token" do
       request = perform(:q => 'hello', :access_token => 'abc123')
-      query_params(request).should eq('q' => 'hello', 'access_token' => 'abc123')
-      auth_header(request).should eq(%(Token token="abc123"))
+      expect(query_params(request)).to eq('q' => 'hello', 'access_token' => 'abc123')
+      expect(auth_header(request)).to eq(%(Token token="abc123"))
     end
 
     it "clears default with empty explicit token" do
       request = perform(:q => 'hello', :access_token => nil)
-      query_params(request).should eq('q' => 'hello', 'access_token' => nil)
-      auth_header(request).should be_nil
+      expect(query_params(request)).to eq('q' => 'hello', 'access_token' => nil)
+      expect(auth_header(request)).to be_nil
     end
   end
 
@@ -74,11 +74,11 @@ describe FaradayMiddleware::OAuth2 do
     subject { perform({:q => 'hello'}, 'Authorization' => 'custom') }
 
     it "adds token param" do
-      query_params(subject).should eq('q' => 'hello', 'access_token' => 'XYZ')
+      expect(query_params(subject)).to eq('q' => 'hello', 'access_token' => 'XYZ')
     end
 
     it "doesn't override existing header" do
-      auth_header(subject).should eq('custom')
+      expect(auth_header(subject)).to eq('custom')
     end
   end
 
@@ -86,13 +86,13 @@ describe FaradayMiddleware::OAuth2 do
     let(:options) { ['XYZ', {:param_name => :oauth}] }
 
     it "adds token param" do
-      query_params(perform).should eq('oauth' => 'XYZ')
+      expect(query_params(perform)).to eq('oauth' => 'XYZ')
     end
 
     it "overrides default with explicit token" do
       request = perform(:oauth => 'abc123')
-      query_params(request).should eq('oauth' => 'abc123')
-      auth_header(request).should eq(%(Token token="abc123"))
+      expect(query_params(request)).to eq('oauth' => 'abc123')
+      expect(auth_header(request)).to eq(%(Token token="abc123"))
     end
   end
 
@@ -100,11 +100,11 @@ describe FaradayMiddleware::OAuth2 do
     let(:options) { [{:param_name => :oauth}] }
 
     it "doesn't add param" do
-      query_params(perform).should be_empty
+      expect(query_params(perform)).to be_empty
     end
 
     it "overrides default with explicit token" do
-      query_params(perform(:oauth => 'abc123')).should eq('oauth' => 'abc123')
+      expect(query_params(perform(:oauth => 'abc123'))).to eq('oauth' => 'abc123')
     end
   end
 
@@ -112,7 +112,7 @@ describe FaradayMiddleware::OAuth2 do
     let(:options) { ['XYZ', {:param_name => nil}] }
 
     it "raises error" do
-      expect { make_app }.to raise_error(ArgumentError, ":param_name can't be blank")
+      expect{ make_app }.to raise_error(ArgumentError, ":param_name can't be blank")
     end
   end
 end

data/spec/oauth_spec.rb

@@ -1,6 +1,7 @@
 require 'helper'
 require 'faraday_middleware/request/oauth'
 require 'uri'
+require 'forwardable'
 
 describe FaradayMiddleware::OAuth do
   def auth_header(env)
@@ -14,11 +15,12 @@ describe FaradayMiddleware::OAuth do
     end
   end
 
-  def perform(oauth_options = {}, headers = {})
+  def perform(oauth_options = {}, headers = {}, params = {})
     env = {
       :url => URI('http://example.com/'),
       :request_headers => Faraday::Utils::Headers.new.update(headers),
-      :request => {}
+      :request => {},
+      :body => params
     }
     unless oauth_options.is_a? Hash and oauth_options.empty?
       env[:request][:oauth] = oauth_options
@@ -34,21 +36,21 @@ describe FaradayMiddleware::OAuth do
   context "invalid options" do
     let(:options) { nil }
 
-    it "should error out" do
-      expect { make_app }.to raise_error(ArgumentError)
+    it "errors out" do
+      expect{ make_app }.to raise_error(ArgumentError)
     end
   end
 
   context "empty options" do
     let(:options) { [{}] }
 
-    it "should sign request" do
+    it "signs request" do
       auth = auth_values(perform)
       expected_keys = %w[ oauth_nonce
                           oauth_signature oauth_signature_method
                           oauth_timestamp oauth_version ]
 
-      auth.keys.should =~ expected_keys
+      expect(auth.keys).to match_array expected_keys
     end
   end
 
@@ -65,27 +67,27 @@ describe FaradayMiddleware::OAuth do
                           oauth_signature oauth_signature_method
                           oauth_timestamp oauth_token oauth_version ]
 
-      auth.keys.should =~ expected_keys
-      auth['oauth_version'].should eq(%("1.0"))
-      auth['oauth_signature_method'].should eq(%("HMAC-SHA1"))
-      auth['oauth_consumer_key'].should eq(%("CKEY"))
-      auth['oauth_token'].should eq(%("TOKEN"))
+      expect(auth.keys).to match_array expected_keys
+      expect(auth['oauth_version']).to eq(%("1.0"))
+      expect(auth['oauth_signature_method']).to eq(%("HMAC-SHA1"))
+      expect(auth['oauth_consumer_key']).to eq(%("CKEY"))
+      expect(auth['oauth_token']).to eq(%("TOKEN"))
     end
 
     it "doesn't override existing header" do
       request = perform({}, "Authorization" => "iz me!")
-      auth_header(request).should eq("iz me!")
+      expect(auth_header(request)).to eq("iz me!")
     end
 
     it "can override oauth options per-request" do
       auth = auth_values(perform(:consumer_key => 'CKEY2'))
 
-      auth['oauth_consumer_key'].should eq(%("CKEY2"))
-      auth['oauth_token'].should eq(%("TOKEN"))
+      expect(auth['oauth_consumer_key']).to eq(%("CKEY2"))
+      expect(auth['oauth_token']).to eq(%("TOKEN"))
     end
 
     it "can turn off oauth signing per-request" do
-      auth_header(perform(false)).should be_nil
+      expect(auth_header(perform(false))).to be_nil
     end
   end
 
@@ -94,8 +96,56 @@ describe FaradayMiddleware::OAuth do
 
     it "adds auth info to the header" do
       auth = auth_values(perform)
-      auth.should include('oauth_consumer_key')
-      auth.should_not include('oauth_token')
+      expect(auth).to include('oauth_consumer_key')
+      expect(auth).not_to include('oauth_token')
     end
   end
+
+  context "handling body parameters" do
+    let(:options) { [{ :consumer_key => 'CKEY',
+                       :consumer_secret => 'CSECRET',
+                       :nonce => '547fed103e122eecf84c080843eedfe6',
+                       :timestamp => '1286830180'}] }
+
+    let(:value) { {'foo' => 'bar'} }
+
+    let(:type_json) { {'Content-Type' => 'application/json'} }
+    let(:type_form) { {'Content-Type' => 'application/x-www-form-urlencoded'} }
+
+    extend Forwardable
+    query_method = :build_nested_query
+    query_module = ::Faraday::Utils.respond_to?(query_method) ? 'Faraday::Utils' : 'Rack::Utils'
+    def_delegator query_module, query_method
+
+    it "does not include the body for JSON" do
+      auth_header_with    = auth_header(perform({}, type_json, '{"foo":"bar"}'))
+      auth_header_without = auth_header(perform({}, type_json, {}))
+
+      expect(auth_header_with).to eq(auth_header_without)
+    end
+
+    it "includes the body parameters with form Content-Type" do
+      auth_header_with    = auth_header(perform({}, type_form, {}))
+      auth_header_without = auth_header(perform({}, type_form, value))
+
+      expect(auth_header_with).not_to eq(auth_header_without)
+    end
+
+    it "includes the body parameters with an unspecified Content-Type" do
+      auth_header_with    = auth_header(perform({}, {}, value))
+      auth_header_without = auth_header(perform({}, type_form, value))
+
+      expect(auth_header_with).to eq(auth_header_without)
+    end
+
+    it "includes the body parameters for form type with string body" do
+      # simulates the behavior of Faraday::MiddleWare::UrlEncoded
+      value = { 'foo' => ['bar', 'baz', 'wat'] }
+      auth_header_hash   = auth_header(perform({}, type_form, value))
+      auth_header_string = auth_header(perform({}, type_form, build_nested_query(value)))
+      expect(auth_header_string).to eq(auth_header_hash)
+    end
+
+  end
+
 end