webmock 1.8.6 → 3.14.0

data/spec/acceptance/curb/curb_spec.rb

@@ -11,9 +11,9 @@ unless RUBY_PLATFORM =~ /java/
 
     describe "when doing PUTs" do
       it "should stub them" do
-        stub_request(:put, "www.example.com").with(:body => "01234")
-        http_request(:put, "http://www.example.com", :body => "01234").
-          status.should == "200"
+        stub_request(:put, "www.example.com").with(body: "01234")
+        expect(http_request(:put, "http://www.example.com", body: "01234").
+          status).to eq("200")
       end
     end
   end
@@ -30,98 +30,132 @@ unless RUBY_PLATFORM =~ /java/
         @curl.url = "http://example.com"
       end
 
+      describe 'on_debug' do
+        it "should call on_debug" do
+          stub_request(:any, "example.com").
+            to_return(status: 200, headers: { 'Server' => 'nginx' }, body: { hello: :world }.to_json)
+
+          test = []
+
+          @curl.on_debug do |message, operation|
+            test << "#{operation} -> #{message}"
+          end
+          @curl.headers['Content-Type'] = 'application/json'
+          @curl.http_post({ hello: :world }.to_json)
+
+          expect(test).to_not be_empty
+        end
+      end
+
       it "should call on_success with 2xx response" do
         body = "on_success fired"
-        stub_request(:any, "example.com").to_return(:body => body)
+        stub_request(:any, "example.com").to_return(body: body)
 
         test = nil
         @curl.on_success do |c|
           test = c.body_str
         end
         @curl.http_get
-        test.should == body
+        expect(test).to eq(body)
       end
 
-      it "should call on_failure with 4xx response" do
+      it "should call on_missing with 4xx response" do
         response_code = 403
         stub_request(:any, "example.com").
-          to_return(:status => [response_code, "None shall pass"])
+          to_return(status: [response_code, "None shall pass"])
 
         test = nil
-        @curl.on_failure do |c, code|
+        @curl.on_missing do |c, code|
           test = code
         end
         @curl.http_get
-        test.should == response_code
+        expect(test).to eq(response_code)
       end
 
       it "should call on_failure with 5xx response" do
         response_code = 599
         stub_request(:any, "example.com").
-          to_return(:status => [response_code, "Server On Fire"])
+          to_return(status: [response_code, "Server On Fire"])
 
         test = nil
         @curl.on_failure do |c, code|
           test = code
         end
         @curl.http_get
-        test.should == response_code
+        expect(test).to eq(response_code)
       end
 
       it "should call on_body when response body is read" do
         body = "on_body fired"
         stub_request(:any, "example.com").
-          to_return(:body => body)
+          to_return(body: body)
 
         test = nil
         @curl.on_body do |data|
           test = data
         end
         @curl.http_get
-        test.should == body
+        expect(test).to eq(body)
+      end
+
+      it "should call on_body for each chunk with chunked response" do
+        stub_request(:any, "example.com").
+          to_return(body: ["first_chunk", "second_chunk"],
+                    headers: {"Transfer-Encoding" => "chunked"})
+
+        test = []
+        @curl.on_body do |data|
+          test << data
+        end
+        @curl.http_get
+        expect(test).to eq(["first_chunk", "second_chunk"])
       end
 
       it "should call on_header when response headers are read" do
         stub_request(:any, "example.com").
-          to_return(:headers => {:one => 1})
+          to_return(headers: {one: 1})
 
-        test = nil
+        test = []
         @curl.on_header do |data|
-          test = data
+          test << data
         end
         @curl.http_get
-        test.should match(/One: 1/)
+        expect(test).to eq([
+          "HTTP/1.1 200 \r\n",
+          'One: 1'
+        ])
       end
 
       it "should call on_complete when request is complete" do
         body = "on_complete fired"
-        stub_request(:any, "example.com").to_return(:body => body)
+        stub_request(:any, "example.com").to_return(body: body)
 
         test = nil
         @curl.on_complete do |curl|
           test = curl.body_str
         end
         @curl.http_get
-        test.should == body
+        expect(test).to eq(body)
       end
 
       it "should call on_progress when portion of response body is read" do
-        stub_request(:any, "example.com").to_return(:body => "01234")
+        stub_request(:any, "example.com").to_return(body: "01234")
 
         test = nil
         @curl.on_progress do |*args|
-          args.length.should == 4
-          args.each {|arg| arg.is_a?(Float).should == true }
+          expect(args.length).to eq(4)
+          args.each {|arg| expect(arg.is_a?(Float)).to eq(true) }
           test = true
         end
         @curl.http_get
-        test.should == true
+        expect(test).to eq(true)
       end
 
       it "should call callbacks in correct order on successful request" do
         stub_request(:any, "example.com")
         order = []
         @curl.on_success {|*args| order << :on_success }
+        @curl.on_missing {|*args| order << :on_missing }
         @curl.on_failure {|*args| order << :on_failure }
         @curl.on_header {|*args| order << :on_header }
         @curl.on_body {|*args| order << :on_body }
@@ -129,13 +163,29 @@ unless RUBY_PLATFORM =~ /java/
         @curl.on_progress {|*args| order << :on_progress }
         @curl.http_get
 
-        order.should == [:on_progress,:on_header,:on_body,:on_complete,:on_success]
+        expect(order).to eq([:on_progress,:on_header,:on_body,:on_complete,:on_success])
       end
 
       it "should call callbacks in correct order on failed request" do
-        stub_request(:any, "example.com").to_return(:status => [500, ""])
+        stub_request(:any, "example.com").to_return(status: [500, ""])
+        order = []
+        @curl.on_success {|*args| order << :on_success }
+        @curl.on_missing {|*args| order << :on_missing }
+        @curl.on_failure {|*args| order << :on_failure }
+        @curl.on_header {|*args| order << :on_header }
+        @curl.on_body {|*args| order << :on_body }
+        @curl.on_complete {|*args| order << :on_complete }
+        @curl.on_progress {|*args| order << :on_progress }
+        @curl.http_get
+
+        expect(order).to eq([:on_progress,:on_header,:on_body,:on_complete,:on_failure])
+      end
+
+      it "should call callbacks in correct order on missing request" do
+        stub_request(:any, "example.com").to_return(status: [403, ""])
         order = []
         @curl.on_success {|*args| order << :on_success }
+        @curl.on_missing {|*args| order << :on_missing }
         @curl.on_failure {|*args| order << :on_failure }
         @curl.on_header {|*args| order << :on_header }
         @curl.on_body {|*args| order << :on_body }
@@ -143,7 +193,7 @@ unless RUBY_PLATFORM =~ /java/
         @curl.on_progress {|*args| order << :on_progress }
         @curl.http_get
 
-        order.should == [:on_progress,:on_header,:on_body,:on_complete,:on_failure]
+        expect(order).to eq([:on_progress,:on_header,:on_body,:on_complete,:on_missing])
       end
     end
 
@@ -158,12 +208,12 @@ unless RUBY_PLATFORM =~ /java/
 
         it 'should be the same as #url even with a location header' do
           stub_request(:any, 'example.com').
-            to_return(:body    => "abc",
-                      :status  => 302,
-                      :headers => { 'Location' => 'http://www.example.com' })
+            to_return(body: "abc",
+                      status: 302,
+                      headers: { 'Location' => 'http://www.example.com' })
 
           @curl.http_get
-          @curl.last_effective_url.should == 'http://example.com'
+          expect(@curl.last_effective_url).to eq('http://example.com')
         end
       end
 
@@ -173,60 +223,60 @@ unless RUBY_PLATFORM =~ /java/
         it 'should be the same as #url when no location header is present' do
           stub_request(:any, "example.com")
           @curl.http_get
-          @curl.last_effective_url.should == 'http://example.com'
+          expect(@curl.last_effective_url).to eq('http://example.com')
         end
 
         it 'should be the value of the location header when present' do
           stub_request(:any, 'example.com').
-            to_return(:headers => { 'Location' => 'http://www.example.com' })
+            to_return(headers: { 'Location' => 'http://www.example.com' })
           stub_request(:any, 'www.example.com')
 
           @curl.http_get
-          @curl.last_effective_url.should == 'http://www.example.com'
+          expect(@curl.last_effective_url).to eq('http://www.example.com')
         end
 
         it 'should work with more than one redirect' do
           stub_request(:any, 'example.com').
-            to_return(:headers => { 'Location' => 'http://www.example.com' })
+            to_return(headers: { 'Location' => 'http://www.example.com' })
           stub_request(:any, 'www.example.com').
-            to_return(:headers => { 'Location' => 'http://blog.example.com' })
+            to_return(headers: { 'Location' => 'http://blog.example.com' })
           stub_request(:any, 'blog.example.com')
 
           @curl.http_get
-          @curl.last_effective_url.should == 'http://blog.example.com'
+          expect(@curl.last_effective_url).to eq('http://blog.example.com')
         end
 
         it 'should maintain the original url' do
           stub_request(:any, 'example.com').
-            to_return(:headers => { 'Location' => 'http://www.example.com' })
+            to_return(headers: { 'Location' => 'http://www.example.com' })
           stub_request(:any, 'www.example.com')
 
           @curl.http_get
-          @curl.url.should == 'http://example.com'
+          expect(@curl.url).to eq('http://example.com')
         end
 
         it 'should have the redirected-to attrs (body, response code)' do
           stub_request(:any, 'example.com').
-            to_return(:body => 'request A',
-                      :status => 302,
-                      :headers => { 'Location' => 'http://www.example.com' })
-          stub_request(:any, 'www.example.com').to_return(:body => 'request B')
+            to_return(body: 'request A',
+                      status: 302,
+                      headers: { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com').to_return(body: 'request B')
 
           @curl.http_get
-          @curl.body_str.should == 'request B'
-          @curl.response_code.should == 200
+          expect(@curl.body_str).to eq('request B')
+          expect(@curl.response_code).to eq(200)
         end
 
         it 'should follow more than one redirect' do
           stub_request(:any, 'example.com').
-            to_return(:headers => { 'Location' => 'http://www.example.com' })
+            to_return(headers: { 'Location' => 'http://www.example.com' })
           stub_request(:any, 'www.example.com').
-            to_return(:headers => { 'Location' => 'http://blog.example.com' })
-          stub_request(:any, 'blog.example.com').to_return(:body => 'blog post')
+            to_return(headers: { 'Location' => 'http://blog.example.com' })
+          stub_request(:any, 'blog.example.com').to_return(body: 'blog post')
 
           @curl.http_get
-          @curl.url.should == 'http://example.com'
-          @curl.body_str.should == 'blog post'
+          expect(@curl.url).to eq('http://example.com')
+          expect(@curl.body_str).to eq('blog post')
         end
       end
     end
@@ -242,28 +292,62 @@ unless RUBY_PLATFORM =~ /java/
           content_type = "application/json"
 
           stub_request(:any, 'example.com').
-            to_return(:body     => "abc",
-                      :status   => 200,
-                      :headers  => { 'Content-Type' => content_type })
+            to_return(body: "abc",
+                      status: 200,
+                      headers: { 'Content-Type' => content_type })
 
           @curl.http_get
-          @curl.content_type.should == content_type
+          expect(@curl.content_type).to eq(content_type)
         end
       end
 
       context "when response does not include Content-Type header" do
         it "returns nil for content_type" do
-          content_type = "application/json"
 
           stub_request(:any, 'example.com').
-            to_return(:body     => "abc",
-                      :status   => 200 )
+            to_return(body: "abc",
+                      status: 200 )
 
           @curl.http_get
-          @curl.content_type.should be_nil
+          expect(@curl.content_type).to be_nil
         end
       end
     end
+
+    describe "#chunked_response?" do
+      before(:each) do
+        @curl = Curl::Easy.new
+        @curl.url = "http://example.com"
+      end
+
+      it "is true when Transfer-Encoding is 'chunked' and body responds to each" do
+        stub_request(:any, 'example.com').
+          to_return(body: ["abc", "def"],
+                    status: 200,
+                    headers: { 'Transfer-Encoding' => 'chunked' })
+
+        @curl.http_get
+        expect(@curl).to be_chunked_response
+      end
+
+      it "is false when Transfer-Encoding is not 'chunked'" do
+        stub_request(:any, 'example.com').
+          to_return(body: ["abc", "def"],
+                    status: 200)
+
+        @curl.http_get
+        expect(@curl).not_to be_chunked_response
+      end
+
+      it "is false when Transfer-Encoding is 'chunked' but body does not respond to each" do
+        stub_request(:any, 'example.com').
+          to_return(body: "abc",
+                    status: 200)
+
+        @curl.http_get
+        expect(@curl).not_to be_chunked_response
+      end
+    end
   end
 
   describe "Webmock with Curb" do
@@ -272,12 +356,54 @@ unless RUBY_PLATFORM =~ /java/
       include CurbSpecHelper::DynamicHttp
 
       it "should work with uppercase arguments" do
-        stub_request(:get, "www.example.com").to_return(:body => "abc")
+        stub_request(:get, "www.example.com").to_return(body: "abc")
 
         c = Curl::Easy.new
         c.url = "http://www.example.com"
         c.http(:GET)
-        c.body_str.should == "abc"
+        expect(c.body_str).to eq("abc")
+      end
+
+      it "should alias body to body_str" do
+        stub_request(:get, "www.example.com").to_return(body: "abc")
+
+        c = Curl::Easy.new
+        c.url = "http://www.example.com"
+        c.http(:GET)
+        expect(c.body).to eq("abc")
+      end
+
+      it "supports array headers passed to Curl::Easy" do
+        stub_request(:get, "www.example.com").with(headers: {'X-One' => '1'}).to_return(body: "abc")
+
+        c = Curl::Easy.new
+        c.url = "http://www.example.com"
+        c.headers = ["X-One: 1"]
+        c.http(:GET)
+        expect(c.body).to eq("abc")
+      end
+
+      describe 'match request body' do
+        it 'for post' do
+          stub_request(:post, "www.example.com").with(body: 'foo=nhe').to_return(body: "abc")
+
+          response = Curl.post("http://www.example.com", {foo: :nhe})
+          expect(response.body_str).to eq("abc")
+        end
+
+        it 'for patch' do
+          stub_request(:patch, "www.example.com").with(body: 'foo=nhe').to_return(body: "abc")
+
+          response = Curl.patch("http://www.example.com", {foo: :nhe})
+          expect(response.body_str).to eq("abc")
+        end
+
+        it 'for put' do
+          stub_request(:put, "www.example.com").with(body: 'foo=nhe').to_return(body: "abc")
+
+          response = Curl.put("http://www.example.com", {foo: :nhe})
+          expect(response.body_str).to eq("abc")
+        end
       end
     end
 
@@ -285,39 +411,50 @@ unless RUBY_PLATFORM =~ /java/
       it_should_behave_like "Curb"
       include CurbSpecHelper::NamedHttp
 
+      it "should reset @webmock_method after each call" do
+        stub_request(:post, "www.example.com").with(body: "01234")
+        c = Curl::Easy.new
+        c.url = "http://www.example.com"
+        c.post_body = "01234"
+        c.http_post
+        expect {
+          c.perform
+        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com))
+      end
+
       it "should work with blank arguments for post" do
-        stub_request(:post, "www.example.com").with(:body => "01234")
+        stub_request(:post, "www.example.com").with(body: "01234")
         c = Curl::Easy.new
         c.url = "http://www.example.com"
         c.post_body = "01234"
         c.http_post
-        c.response_code.should == 200
+        expect(c.response_code).to eq(200)
       end
 
       it "should work with several body arguments for post using the class method" do
-        stub_request(:post, "www.example.com").with(:user => {:first_name=>'Bartosz', :last_name=>'Blimke'})
+        stub_request(:post, "www.example.com").with(body: {user: {first_name: 'Bartosz', last_name: 'Blimke'}})
         c = Curl::Easy.http_post "http://www.example.com", 'user[first_name]=Bartosz', 'user[last_name]=Blimke'
-        c.response_code.should == 200
+        expect(c.response_code).to eq(200)
       end
 
       it "should work with blank arguments for put" do
-        stub_request(:put, "www.example.com").with(:body => "01234")
+        stub_request(:put, "www.example.com").with(body: "01234")
         c = Curl::Easy.new
         c.url = "http://www.example.com"
         c.put_data = "01234"
         c.http_put
-        c.response_code.should == 200
+        expect(c.response_code).to eq(200)
       end
 
       it "should work with multiple arguments for post" do
-        data = { :name => "john", :address => "111 example ave" }
+        data = { name: "john", address: "111 example ave" }
 
-        stub_request(:post, "www.example.com").with(:body => data)
+        stub_request(:post, "www.example.com").with(body: data)
         c = Curl::Easy.new
         c.url = "http://www.example.com"
         c.http_post Curl::PostField.content('name', data[:name]),  Curl::PostField.content('address', data[:address])
 
-        c.response_code.should == 200
+        expect(c.response_code).to eq(200)
       end
 
     end
@@ -336,5 +473,27 @@ unless RUBY_PLATFORM =~ /java/
       it_should_behave_like "Curb"
       include CurbSpecHelper::ClassPerform
     end
+
+    describe "using #reset" do
+      before do
+        @curl = Curl::Easy.new
+        @curl.url = "http://example.com"
+        stub_request(:any, "example.com").
+          to_return(body: "abc",
+                    headers: { "Content-Type" => "application/json" })
+        @curl.http_get
+      end
+
+      it "should clear all memoized response fields" do
+        @curl.reset
+        expect(@curl).to have_attributes(
+          body_str: nil,
+          content_type: nil,
+          header_str: nil,
+          last_effective_url: nil,
+          response_code: 0,
+        )
+      end
+    end
   end
 end

data/spec/acceptance/curb/curb_spec_helper.rb

@@ -21,18 +21,21 @@ module CurbSpecHelper
     end
 
     OpenStruct.new(
-      :body => curl.body_str,
-      :headers => WebMock::Util::Headers.normalize_headers(response_headers),
-      :status => curl.response_code.to_s,
-      :message => status
+      body: curl.body_str,
+      headers: WebMock::Util::Headers.normalize_headers(response_headers),
+      status: curl.response_code.to_s,
+      message: status
     )
   end
 
   def setup_request(uri, curl, options={})
     curl          ||= Curl::Easy.new
-    curl.url      = uri.omit(:userinfo).to_s
-    curl.username = uri.user
-    curl.password = uri.password
+    curl.url      = uri.to_s
+    if options[:basic_auth]
+      curl.http_auth_types = :basic
+      curl.username = options[:basic_auth][0]
+      curl.password = options[:basic_auth][1]
+    end
     curl.timeout  = 30
     curl.connect_timeout = 30
 
@@ -66,7 +69,7 @@ module CurbSpecHelper
         curl.put_data = body
       end
 
-      curl.http(method)
+      curl.http(method.to_s.upcase)
       curl
     end
   end