faraday_middleware 0.8.8 → 0.9.0

data/spec/parse_json_spec.rb

@@ -4,17 +4,17 @@ require 'faraday_middleware/response/parse_json'
 describe FaradayMiddleware::ParseJson, :type => :response do
   context "no type matching" do
     it "doesn't change nil body" do
-      process(nil).body.should be_nil
+      expect(process(nil).body).to be_nil
     end
 
     it "nullifies empty body" do
-      process('').body.should be_nil
+      expect(process('').body).to be_nil
     end
 
     it "parses json body" do
       response = process('{"a":1}')
-      response.body.should eql('a' => 1)
-      response.env[:raw_body].should be_nil
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to be_nil
     end
   end
 
@@ -23,13 +23,13 @@ describe FaradayMiddleware::ParseJson, :type => :response do
 
     it "parses json body" do
       response = process('{"a":1}')
-      response.body.should eql('a' => 1)
-      response.env[:raw_body].should eql('{"a":1}')
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to eq('{"a":1}')
     end
 
     it "can opt out of preserving raw" do
       response = process('{"a":1}', nil, :preserve_raw => false)
-      response.env[:raw_body].should be_nil
+      expect(response.env[:raw_body]).to be_nil
     end
   end
 
@@ -38,12 +38,12 @@ describe FaradayMiddleware::ParseJson, :type => :response do
 
     it "parses json body of correct type" do
       response = process('{"a":1}', 'application/x-json')
-      response.body.should eql('a' => 1)
+      expect(response.body).to eq('a' => 1)
     end
 
     it "ignores json body of incorrect type" do
       response = process('{"a":1}', 'text/json-xml')
-      response.body.should eql('{"a":1}')
+      expect(response.body).to eq('{"a":1}')
     end
   end
 
@@ -51,18 +51,18 @@ describe FaradayMiddleware::ParseJson, :type => :response do
     let(:options) { {:content_type => %w[a/b c/d]} }
 
     it "parses json body of correct type" do
-      process('{"a":1}', 'a/b').body.should be_a(Hash)
-      process('{"a":1}', 'c/d').body.should be_a(Hash)
+      expect(process('{"a":1}', 'a/b').body).to be_a(Hash)
+      expect(process('{"a":1}', 'c/d').body).to be_a(Hash)
     end
 
     it "ignores json body of incorrect type" do
-      process('{"a":1}', 'a/d').body.should_not be_a(Hash)
+      expect(process('{"a":1}', 'a/d').body).not_to be_a(Hash)
     end
   end
 
   it "chokes on invalid json" do
     ['{!', '"a"', 'true', 'null', '1'].each do |data|
-      expect { process(data) }.to raise_error(Faraday::Error::ParsingError)
+      expect{ process(data) }.to raise_error(Faraday::Error::ParsingError)
     end
   end
 
@@ -76,37 +76,37 @@ describe FaradayMiddleware::ParseJson, :type => :response do
 
     it "ignores completely incompatible type" do
       response = process('{"a":1}', 'application/xml')
-      response.body.should eql('{"a":1}')
+      expect(response.body).to eq('{"a":1}')
     end
 
     it "ignores compatible type with bad data" do
       response = process('var a = 1', 'text/javascript')
-      response.body.should eql('var a = 1')
-      response['content-type'].should eql('text/javascript')
+      expect(response.body).to eq('var a = 1')
+      expect(response['content-type']).to eq('text/javascript')
     end
 
     it "corrects compatible type and data" do
       response = process('{"a":1}', 'text/javascript')
-      response.body.should be_a(Hash)
-      response['content-type'].should eql('application/json')
+      expect(response.body).to be_a(Hash)
+      expect(response['content-type']).to eq('application/json')
     end
 
     it "corrects compatible type even when data starts with whitespace" do
       response = process(%( \r\n\t{"a":1}), 'text/javascript')
-      response.body.should be_a(Hash)
-      response['content-type'].should eql('application/json')
+      expect(response.body).to be_a(Hash)
+      expect(response['content-type']).to eq('application/json')
     end
   end
 
   context "HEAD responses" do
-    it "should nullify the body if it's only one space" do
+    it "nullifies the body if it's only one space" do
       response = process(' ')
-      response.body.should be_nil
+      expect(response.body).to be_nil
     end
 
-    it "should nullify the body if it's two spaces" do
+    it "nullifies the body if it's two spaces" do
       response = process(' ')
-      response.body.should be_nil
+      expect(response.body).to be_nil
     end
   end
 end

data/spec/parse_marshal_spec.rb

@@ -3,14 +3,14 @@ require 'faraday_middleware/response/parse_marshal'
 
 describe FaradayMiddleware::ParseMarshal, :type => :response do
   it "restores a marshaled dump" do
-    process(Marshal.dump(:a => 1)).body.should be_eql(:a => 1)
+    expect(process(Marshal.dump(:a => 1)).body).to be_eql(:a => 1)
   end
 
   it "nulifies blank response" do
-    process('').body.should be_nil
+    expect(process('').body).to be_nil
   end
 
   it "chokes on invalid content" do
-    expect { process('abc') }.to raise_error(Faraday::Error::ParsingError)
+    expect{ process('abc') }.to raise_error(Faraday::Error::ParsingError)
   end
 end

data/spec/parse_xml_spec.rb

@@ -7,17 +7,17 @@ describe FaradayMiddleware::ParseXml, :type => :response do
 
   context "no type matching" do
     it "doesn't change nil body" do
-      process(nil).body.should be_nil
+      expect(process(nil).body).to be_nil
     end
 
     it "turns empty body into empty hash" do
-      process('').body.should be_eql({})
+      expect(process('').body).to be_eql({})
     end
 
     it "parses xml body" do
       response = process(xml)
-      response.body.should eql(user)
-      response.env[:raw_body].should be_nil
+      expect(response.body).to eq(user)
+      expect(response.env[:raw_body]).to be_nil
     end
   end
 
@@ -26,13 +26,13 @@ describe FaradayMiddleware::ParseXml, :type => :response do
 
     it "parses xml body" do
       response = process(xml)
-      response.body.should eql(user)
-      response.env[:raw_body].should eql(xml)
+      expect(response.body).to eq(user)
+      expect(response.env[:raw_body]).to eq(xml)
     end
 
     it "can opt out of preserving raw" do
       response = process(xml, nil, :preserve_raw => false)
-      response.env[:raw_body].should be_nil
+      expect(response.env[:raw_body]).to be_nil
     end
   end
 
@@ -41,12 +41,12 @@ describe FaradayMiddleware::ParseXml, :type => :response do
 
     it "parses xml body of correct type" do
       response = process(xml, 'application/xml')
-      response.body.should eql(user)
+      expect(response.body).to eq(user)
     end
 
     it "ignores xml body of incorrect type" do
       response = process(xml, 'text/html')
-      response.body.should eql(xml)
+      expect(response.body).to eq(xml)
     end
   end
 
@@ -54,18 +54,18 @@ describe FaradayMiddleware::ParseXml, :type => :response do
     let(:options) { {:content_type => %w[a/b c/d]} }
 
     it "parses xml body of correct type" do
-      process(xml, 'a/b').body.should be_a(Hash)
-      process(xml, 'c/d').body.should be_a(Hash)
+      expect(process(xml, 'a/b').body).to be_a(Hash)
+      expect(process(xml, 'c/d').body).to be_a(Hash)
     end
 
     it "ignores xml body of incorrect type" do
-      process(xml, 'a/d').body.should_not be_a(Hash)
+      expect(process(xml, 'a/d').body).not_to be_a(Hash)
     end
   end
 
   it "chokes on invalid xml" do
     ['{!', '"a"', 'true', 'null', '1'].each do |data|
-      expect { process(data) }.to raise_error(Faraday::Error::ParsingError)
+      expect{ process(data) }.to raise_error(Faraday::Error::ParsingError)
     end
   end
 end

data/spec/parse_yaml_spec.rb

@@ -4,17 +4,17 @@ require 'faraday_middleware/response/parse_yaml'
 describe FaradayMiddleware::ParseYaml, :type => :response do
   context "no type matching" do
     it "doesn't change nil body" do
-      process(nil).body.should be_nil
+      expect(process(nil).body).to be_nil
     end
 
     it "returns false for empty body" do
-      process('').body.should be_false
+      expect(process('').body).to be_false
     end
 
     it "parses yaml body" do
       response = process('a: 1')
-      response.body.should eql('a' => 1)
-      response.env[:raw_body].should be_nil
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to be_nil
     end
   end
 
@@ -23,13 +23,13 @@ describe FaradayMiddleware::ParseYaml, :type => :response do
 
     it "parses yaml body" do
       response = process('a: 1')
-      response.body.should eql('a' => 1)
-      response.env[:raw_body].should eql('a: 1')
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to eq('a: 1')
     end
 
     it "can opt out of preserving raw" do
       response = process('a: 1', nil, :preserve_raw => false)
-      response.env[:raw_body].should be_nil
+      expect(response.env[:raw_body]).to be_nil
     end
   end
 
@@ -38,16 +38,16 @@ describe FaradayMiddleware::ParseYaml, :type => :response do
 
     it "parses json body of correct type" do
       response = process('a: 1', 'application/x-yaml')
-      response.body.should eql('a' => 1)
+      expect(response.body).to eq('a' => 1)
     end
 
     it "ignores json body of incorrect type" do
       response = process('a: 1', 'text/yaml-xml')
-      response.body.should eql('a: 1')
+      expect(response.body).to eq('a: 1')
     end
   end
 
   it "chokes on invalid yaml" do
-    expect { process('{!') }.to raise_error(Faraday::Error::ParsingError)
+    expect{ process('{!') }.to raise_error(Faraday::Error::ParsingError)
   end
 end

data/spec/rashify_spec.rb

@@ -3,52 +3,52 @@ require 'faraday_middleware/response/rashify'
 
 describe FaradayMiddleware::Rashify do
 
-  context 'when used' do
+  context "when used" do
     let(:rashify) { described_class.new }
 
-    it 'should create a Hashie::Rash from the body' do
+    it "creates a Hashie::Rash from the body" do
       env = { :body => { "name" => "Erik Michaels-Ober", "username" => "sferik" } }
       me  = rashify.on_complete(env)
-      me.class.should == Hashie::Rash
+      expect(me.class).to eq(Hashie::Rash)
     end
 
-    it 'should handle strings' do
+    it "handles strings" do
       env = { :body => "Most amazing string EVER" }
       me  = rashify.on_complete(env)
-      me.should == "Most amazing string EVER"
+      expect(me).to eq("Most amazing string EVER")
     end
 
-    it 'should handle hashes and decamelcase the keys' do
+    it "handles hashes and decamelcase the keys" do
       env = { :body => { "name" => "Erik Michaels-Ober", "userName" => "sferik" } }
       me  = rashify.on_complete(env)
-      me.name.should == 'Erik Michaels-Ober'
-      me.user_name.should == 'sferik'
+      expect(me.name).to eq('Erik Michaels-Ober')
+      expect(me.user_name).to eq('sferik')
     end
 
-    it 'should handle arrays' do
+    it "handles arrays" do
       env = { :body => [123, 456] }
       values = rashify.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  = rashify.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 mixed arrays" do
       env = { :body => [123, { "username" => "sferik" }, 456] }
       values = rashify.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
   end
 
-  context 'integration test' do
+  context "integration test" do
     let(:stubs) { Faraday::Adapter::Test::Stubs.new }
     let(:connection) do
       Faraday::Connection.new do |builder|
@@ -59,14 +59,14 @@ describe FaradayMiddleware::Rashify 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faraday_middleware
 version: !ruby/object:Gem::Version
-  version: 0.8.8
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-24 00:00:00.000000000 Z
+date: 2012-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -170,6 +170,7 @@ files:
 - lib/faraday_middleware/instrumentation.rb
 - lib/faraday_middleware/rack_compatible.rb
 - lib/faraday_middleware/request/encode_json.rb
+- lib/faraday_middleware/request/method_override.rb
 - lib/faraday_middleware/request/oauth.rb
 - lib/faraday_middleware/request/oauth2.rb
 - lib/faraday_middleware/response/caching.rb
@@ -190,6 +191,7 @@ files:
 - spec/follow_redirects_spec.rb
 - spec/helper.rb
 - spec/mashify_spec.rb
+- spec/method_override_spec.rb
 - spec/oauth2_spec.rb
 - spec/oauth_spec.rb
 - spec/parse_dates_spec.rb
@@ -229,6 +231,7 @@ test_files:
 - spec/follow_redirects_spec.rb
 - spec/helper.rb
 - spec/mashify_spec.rb
+- spec/method_override_spec.rb
 - spec/oauth2_spec.rb
 - spec/oauth_spec.rb
 - spec/parse_dates_spec.rb