faraday_middleware 0.8.8 → 0.9.0

data/spec/helper.rb

@@ -41,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,80 +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 nested arrays of hashes' do
+    it "handles nested arrays of hashes" do
       env = { :body => [[{ "username" => "sferik" }, { "username" => "pengwynn" }]] }
       us  = mashify.on_complete(env)
-      us.first.first.username.should == 'sferik'
-      us.first.last.username.should == 'pengwynn'
+      expect(us.first.first.username).to eq('sferik')
+      expect(us.first.last.username).to eq('pengwynn')
     end
 
-    it 'should handle mixed arrays' do
+    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 at the class level' 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 'should allow for use of custom Mash subclasses at the instance level' do
+    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)
 
-      me.class.should == MyMash
+      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|
@@ -86,14 +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
+    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

@@ -36,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
 
@@ -67,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
 
@@ -96,8 +96,8 @@ 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
 
@@ -121,21 +121,21 @@ describe FaradayMiddleware::OAuth do
       auth_header_with    = auth_header(perform({}, type_json, '{"foo":"bar"}'))
       auth_header_without = auth_header(perform({}, type_json, {}))
 
-      auth_header_with.should == auth_header_without
+      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))
 
-      auth_header_with.should_not == auth_header_without
+      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))
 
-      auth_header_with.should == auth_header_without
+      expect(auth_header_with).to eq(auth_header_without)
     end
 
     it "includes the body parameters for form type with string body" do
@@ -143,7 +143,7 @@ describe FaradayMiddleware::OAuth do
       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)))
-      auth_header_string.should == auth_header_hash
+      expect(auth_header_string).to eq(auth_header_hash)
     end
 
   end

data/spec/parse_dates_spec.rb

@@ -11,32 +11,29 @@ describe FaradayMiddleware::ParseDates, :type => :response do
     end
   }
 
-  it "should parse dates" do
-    process({"x" => "2012-02-01T13:14:15Z"}).body["x"].to_s.should == parsed
+  it "parses dates" do
+    expect(process({"x" => "2012-02-01T13:14:15Z"}).body["x"].to_s).to eq(parsed)
   end
 
-  it "should parse nested dates in hash" do
-    process({"x" => {"y" => "2012-02-01T13:14:15Z"}}).body["x"]["y"].to_s.should == parsed
+  it "parses nested dates in hash" do
+    expect(process({"x" => {"y" => "2012-02-01T13:14:15Z"}}).body["x"]["y"].to_s).to eq(parsed)
   end
 
-  it "should parse nested dates in arrays" do
-    process({"x" => [{"y" =>"2012-02-01T13:14:15Z"}]}).body["x"][0]["y"].to_s.should == parsed
+  it "parses nested dates in arrays" do
+    expect(process({"x" => [{"y" =>"2012-02-01T13:14:15Z"}]}).body["x"][0]["y"].to_s).to eq(parsed)
   end
 
-  it "should not blow up on empty body" do
-    process(nil).body.should == nil
+  it "returns nil when body is empty" do
+    expect(process(nil).body).to eq(nil)
   end
 
-  it "should leave arrays with ids alone" do
-    process({"x" => [1,2,3]}).body.should == {"x" => [1,2,3]}
+  it "leaves arrays with ids alone" do
+    expect(process({"x" => [1,2,3]}).body).to eq({"x" => [1,2,3]})
   end
 
-  it "should not parse date-like things" do
-    process({"x" => "2012-02-01T13:14:15Z bla"}).body["x"].to_s.should ==
-      "2012-02-01T13:14:15Z bla"
-    process({"x" => "12012-02-01T13:14:15Z"}).body["x"].to_s.should ==
-      "12012-02-01T13:14:15Z"
-    process({"x" => "2012-02-01T13:14:15Z\nfoo"}).body["x"].to_s.should ==
-      "2012-02-01T13:14:15Z\nfoo"
+  it "does not parse date-like things" do
+    expect(process({"x" => "2012-02-01T13:14:15Z bla"}).body["x"].to_s).to eq "2012-02-01T13:14:15Z bla"
+    expect(process({"x" => "12012-02-01T13:14:15Z"}).body["x"].to_s).to eq "12012-02-01T13:14:15Z"
+    expect(process({"x" => "2012-02-01T13:14:15Z\nfoo"}).body["x"].to_s).to eq "2012-02-01T13:14:15Z\nfoo"
   end
 end