webmock 1.8.6 → 3.14.0

data/spec/acceptance/em_http_request/em_http_request_spec.rb

@@ -13,10 +13,43 @@ unless RUBY_PLATFORM =~ /java/
 
     #functionality only supported for em-http-request 1.x
     if defined?(EventMachine::HttpConnection)
+      context 'when a real request is made and redirects are followed', net_connect: true do
+        before { WebMock.allow_net_connect! }
+
+        # This url redirects to the https URL.
+        let(:http_url) { "http://raw.github.com:80/gist/fb555cb593f3349d53af/6921dd638337d3f6a51b0e02e7f30e3c414f70d6/vcr_gist" }
+        let(:https_url) { http_url.gsub('http', 'https').gsub('80', '443') }
+
+        def make_request
+          EM.run do
+            request = EM::HttpRequest.new(http_url).get(redirects: 1)
+            request.callback { EM.stop }
+          end
+        end
+
+        it "invokes the globally_stub_request hook with both requests" do
+          urls = []
+          WebMock.globally_stub_request { |r| urls << r.uri.to_s; nil }
+
+          make_request
+
+          expect(urls).to eq([http_url, https_url])
+        end
+
+        it 'invokes the after_request hook with both requests' do
+          urls = []
+          WebMock.after_request { |req, res| urls << req.uri.to_s }
+
+          make_request
+
+          expect(urls).to eq([http_url, https_url])
+        end
+      end
+
       describe "with middleware" do
 
         it "should work with request middleware" do
-          stub_request(:get, "www.example.com").with(:body => 'bar')
+          stub_request(:get, "www.example.com").with(body: 'bar')
 
           middleware = Class.new do
             def request(client, head, body)
@@ -29,37 +62,142 @@ unless RUBY_PLATFORM =~ /java/
 
             conn.use middleware
 
-            http = conn.get(:body => 'foo')
+            http = conn.get(body: 'foo')
 
             http.callback do
-              WebMock.should have_requested(:get, "www.example.com").with(:body => 'bar')
+              expect(WebMock).to have_requested(:get, "www.example.com").with(body: 'bar')
               EM.stop
             end
           end
         end
 
-        it "should work with response middleware" do
-          stub_request(:get, "www.example.com").to_return(:body => 'foo')
+        it "only calls request middleware once" do
+          stub_request(:get, "www.example.com")
 
           middleware = Class.new do
+            def self.called!
+              @called = called + 1
+            end
+
+            def self.called
+              @called || 0
+            end
+
+            def request(client, head, body)
+              self.class.called!
+              [head, body]
+            end
+          end
+
+          EM.run do
+            conn = EventMachine::HttpRequest.new('http://www.example.com/')
+            conn.use middleware
+            http = conn.get
+            http.callback do
+              expect(middleware.called).to eq(1)
+              EM.stop
+            end
+          end
+        end
+
+        let(:response_middleware) do
+          Class.new do
             def response(resp)
               resp.response = 'bar'
             end
           end
+        end
+
+        it "should work with response middleware" do
+          stub_request(:get, "www.example.com").to_return(body: 'foo')
 
           EM.run do
             conn = EventMachine::HttpRequest.new('http://www.example.com/')
 
-            conn.use middleware
+            conn.use response_middleware
 
             http = conn.get
 
             http.callback do
-              http.response.should be == 'bar'
+              expect(http.response).to eq('bar')
               EM.stop
             end
           end
         end
+
+        let(:webmock_server_url) { "http://#{WebMockServer.instance.host_with_port}/" }
+
+        shared_examples_for "em-http-request middleware/after_request hook integration" do
+          it 'yields the original raw body to the after_request hook even if a response middleware modifies the body' do
+            yielded_response_body = nil
+            ::WebMock.after_request do |request, response|
+              yielded_response_body = response.body
+            end
+
+            EM::HttpRequest.use response_middleware
+
+            EM.run do
+              http = EventMachine::HttpRequest.new(webmock_server_url).get
+              http.callback { EM.stop }
+            end
+
+            expect(yielded_response_body).to eq("hello world")
+          end
+        end
+
+        context 'making a real request', net_connect: true do
+          before { WebMock.allow_net_connect! }
+          include_examples "em-http-request middleware/after_request hook integration"
+
+          it "only calls request middleware once" do
+            middleware = Class.new do
+              def self.called!
+                @called = called + 1
+              end
+
+              def self.called
+                @called || 0
+              end
+
+              def request(client, head, body)
+                self.class.called!
+                [head, body]
+              end
+            end
+
+            EM.run do
+              conn = EventMachine::HttpRequest.new(webmock_server_url)
+              conn.use middleware
+              http = conn.get
+              http.callback do
+                expect(middleware.called).to eq(1)
+                EM.stop
+              end
+            end
+          end
+        end
+
+        context 'when the request is stubbed' do
+          before { stub_request(:get, webmock_server_url).to_return(body: 'hello world') }
+          include_examples "em-http-request middleware/after_request hook integration"
+        end
+      end
+
+      it 'should trigger error callbacks asynchronously' do
+        stub_request(:get, 'www.example.com').to_timeout
+        called = false
+
+        EM.run do
+          conn = EventMachine::HttpRequest.new('http://www.example.com/')
+          http = conn.get
+          http.errback do
+            called = true
+            EM.stop
+          end
+          expect(called).to eq(false)
+        end
+
+        expect(called).to eq(true)
       end
 
       # not pretty, but it works
@@ -78,16 +216,16 @@ unless RUBY_PLATFORM =~ /java/
           end
 
           it "should work" do
-            stub_request(:post, /.*.testserver.com*/).to_return(:status => 200, :body => 'ok')
-            lambda {
+            stub_request(:post, /.*.testserver.com*/).to_return(status: 200, body: 'ok')
+            expect {
               EM.run do
                 fiber = Fiber.new do
-                  http = EM::HttpRequest.new("http://www.testserver.com").post :body => "foo=bar&baz=bang", :timeout => 60
+                  EM::HttpRequest.new("http://www.testserver.com").post body: "foo=bar&baz=bang", timeout: 60
                   EM.stop
                 end
                 fiber.resume
               end
-            }.should_not raise_error
+            }.not_to raise_error
           end
 
           after(:each) do
@@ -105,62 +243,218 @@ unless RUBY_PLATFORM =~ /java/
     end
 
     it "should work with streaming" do
-      stub_request(:get, "www.example.com").to_return(:body => "abc")
+      stub_request(:get, "www.example.com").to_return(body: "abc")
       response = ""
       EM.run {
         http = EventMachine::HttpRequest.new('http://www.example.com/').get
         http.stream { |chunk| response = chunk; EM.stop  }
       }
-      response.should == "abc"
+      expect(response).to eq("abc")
     end
 
     it "should work with responses that use chunked transfer encoding" do
-      stub_request(:get, "www.example.com").to_return(:body => "abc", :headers => { 'Transfer-Encoding' => 'chunked' })
-      http_request(:get, "http://www.example.com").body.should == "abc"
+      stub_request(:get, "www.example.com").to_return(body: "abc", headers: { 'Transfer-Encoding' => 'chunked' })
+      expect(http_request(:get, "http://www.example.com").body).to eq("abc")
     end
 
     it "should work with optional query params" do
-      stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(:body => "abc")
-      http_request(:get, "http://www.example.com/?x=3", :query => {"a" => ["b", "c"]}).body.should == "abc"
+      stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(body: "abc")
+      expect(http_request(:get, "http://www.example.com/?x=3", query: {"a" => ["b", "c"]}).body).to eq("abc")
     end
 
     it "should work with optional query params declared as string" do
-      stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(:body => "abc")
-      http_request(:get, "http://www.example.com/?x=3", :query => "a[]=b&a[]=c").body.should == "abc"
+      stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(body: "abc")
+      expect(http_request(:get, "http://www.example.com/?x=3", query: "a[]=b&a[]=c").body).to eq("abc")
     end
 
     it "should work when the body is passed as a Hash" do
-      stub_request(:post, "www.example.com").with(:body => {:a => "1", :b => "2"}).to_return(:body => "ok")
-      http_request(:post, "http://www.example.com", :body => {:a => "1", :b => "2"}).body.should == "ok"
+      stub_request(:post, "www.example.com").with(body: {a: "1", b: "2"}).to_return(body: "ok")
+      expect(http_request(:post, "http://www.example.com", body: {a: "1", b: "2"}).body).to eq("ok")
+    end
+
+    if defined?(EventMachine::HttpConnection)
+      it "should work when a file is passed as body" do
+        stub_request(:post, "www.example.com").with(body: File.read(__FILE__)).to_return(body: "ok")
+        expect(http_request(:post, "http://www.example.com", file: __FILE__).body).to eq("ok")
+      end
     end
 
     it "should work with UTF-8 strings" do
       body = "Привет, Мир!"
-      stub_request(:post, "www.example.com").to_return(:body => body)
-      http_request(:post, "http://www.example.com").body.bytesize.should == body.bytesize
+      stub_request(:post, "www.example.com").to_return(body: body)
+      expect(http_request(:post, "http://www.example.com").body.bytesize).to eq(body.bytesize)
+    end
+
+    it "should work with multiple requests to the same connection" do
+      stub_request(:get, "www.example.com/foo").to_return(body: "bar")
+      stub_request(:get, "www.example.com/baz").to_return(body: "wombat")
+      err1  = nil
+      err2  = nil
+      body1 = nil
+      body2 = nil
+      i = 0
+
+      EM.run do
+        conn = EM::HttpRequest.new("http://www.example.com")
+        conn.get(path: "/foo").callback do |resp|
+          body1 = resp.response
+          i += 1; EM.stop if i == 2
+        end.errback do |resp|
+          err1  = resp.error
+          i += 1; EM.stop if i == 2
+        end
+
+        conn.get(path: "/baz").callback do |resp|
+          body2 = resp.response
+          i += 1; EM.stop if i == 2
+        end.errback do |resp|
+          err2  = resp.error
+          i += 1; EM.stop if i == 2
+        end
+      end
+
+      expect(err1).to be(nil)
+      expect(err2).to be(nil)
+      expect(body1).to eq("bar")
+      expect(body2).to eq("wombat")
+    end
+
+    it "should work with multiple requests to the same connection when the first request times out" do
+      stub_request(:get, "www.example.com/foo").to_timeout.then.to_return(status: 200, body: "wombat")
+      err  = nil
+      body = nil
+
+      EM.run do
+        conn = EM::HttpRequest.new("http://www.example.com")
+        conn.get(path: "/foo").callback do |resp|
+          err = :success_from_timeout
+          EM.stop
+        end.errback do |resp|
+          conn.get(path: "/foo").callback do |retry_resp|
+            expect(retry_resp.response_header.status).to eq(200)
+            body = retry_resp.response
+            EM.stop
+          end.errback do |retry_resp|
+            err = retry_resp.error
+            EM.stop
+          end
+        end
+      end
+
+      expect(err).to be(nil)
+      expect(body).to eq("wombat")
     end
 
     describe "mocking EM::HttpClient API" do
+      let(:uri) { "http://www.example.com/" }
+
       before do
-        stub_request(:get, "www.example.com/")
+        stub_request(:get, uri)
         WebMock::HttpLibAdapters::EmHttpRequestAdapter.enable!
       end
-      subject do
+
+      def client(uri, options = {})
         client = nil
         EM.run do
-          client = EventMachine::HttpRequest.new('http://www.example.com/').get
+          client = EventMachine::HttpRequest.new(uri).get(options)
           client.callback { EM.stop }
           client.errback { failed }
         end
         client
       end
 
+      subject { client(uri) }
+
       it 'should support #uri' do
-        subject.uri.should == Addressable::URI.parse('http://www.example.com/')
+        expect(subject.uri).to eq(Addressable::URI.parse(uri))
       end
 
       it 'should support #last_effective_url' do
-        subject.last_effective_url.should == Addressable::URI.parse('http://www.example.com/')
+        expect(subject.last_effective_url).to eq(Addressable::URI.parse(uri))
+      end
+
+      context "with a query" do
+        let(:uri) { "http://www.example.com/?a=1&b=2" }
+        subject { client("http://www.example.com/?a=1", query: { 'b' => 2 }) }
+
+        it "#request_signature doesn't mutate the original uri" do
+          expect(subject.uri).to eq(Addressable::URI.parse("http://www.example.com/?a=1"))
+          signature = WebMock::RequestRegistry.instance.requested_signatures.hash.keys.first
+          expect(signature.uri).to eq(Addressable::URI.parse(uri))
+        end
+      end
+
+      describe 'get_response_cookie' do
+
+        before(:each) do
+          stub_request(:get, "http://example.org/").
+          to_return(
+            status: 200,
+            body: "",
+            headers: { 'Set-Cookie' => cookie_string }
+          )
+        end
+
+        describe 'success' do
+
+          context 'with only one cookie' do
+
+            let(:cookie_name) { 'name_of_the_cookie' }
+            let(:cookie_value) { 'value_of_the_cookie' }
+            let(:cookie_string) { "#{cookie_name}=#{cookie_value}" }
+
+            it 'successfully gets the cookie' do
+              EM.run {
+                http = EventMachine::HttpRequest.new('http://example.org').get
+
+                http.errback { fail(http.error) }
+                http.callback {
+                  expect(http.get_response_cookie(cookie_name)).to eq(cookie_value)
+                  EM.stop
+                }
+              }
+            end
+          end
+
+          context 'with several cookies' do
+
+            let(:cookie_name) { 'name_of_the_cookie' }
+            let(:cookie_value) { 'value_of_the_cookie' }
+            let(:cookie_2_name) { 'name_of_the_2nd_cookie' }
+            let(:cookie_2_value) { 'value_of_the_2nd_cookie' }
+            let(:cookie_string) { %W(#{cookie_name}=#{cookie_value} #{cookie_2_name}=#{cookie_2_value}) }
+
+            it 'successfully gets both cookies' do
+              EM.run {
+                http = EventMachine::HttpRequest.new('http://example.org').get
+
+                http.errback { fail(http.error) }
+                http.callback {
+                  expect(http.get_response_cookie(cookie_name)).to eq(cookie_value)
+                  expect(http.get_response_cookie(cookie_2_name)).to eq(cookie_2_value)
+                  EM.stop
+                }
+              }
+            end
+          end
+        end
+
+        describe 'failure' do
+
+          let(:cookie_string) { 'a=b' }
+
+          it 'returns nil when no cookie is found' do
+            EM.run {
+                http = EventMachine::HttpRequest.new('http://example.org').get
+
+                http.errback { fail(http.error) }
+                http.callback {
+                  expect(http.get_response_cookie('not_found_cookie')).to eq(nil)
+                  EM.stop
+                }
+              }
+          end
+        end
       end
     end
 

data/spec/acceptance/em_http_request/em_http_request_spec_helper.rb

@@ -8,6 +8,9 @@ module EMHttpRequestSpecHelper
   def http_request(method, uri, options = {}, &block)
     @http = nil
     head = options[:headers] || {}
+    if options[:basic_auth]
+      head.merge!('authorization' => options[:basic_auth])
+    end
     response = nil
     error = nil
     error_set = false
@@ -15,10 +18,12 @@ module EMHttpRequestSpecHelper
     EventMachine.run {
       request = EventMachine::HttpRequest.new("#{uri.normalize.to_s}")
       http = request.send(method, {
-        :timeout => 30,
-        :body => options[:body],
-        :query => options[:query],
-        :head => head.merge('authorization' => [uri.user, uri.password])
+        timeout: 30,
+        body: options[:body],
+        file: options[:file],
+        query: options[:query],
+        head: head,
+        compressed: false
       }, &block)
       http.errback {
         error_set = true
@@ -31,10 +36,10 @@ module EMHttpRequestSpecHelper
       }
       http.callback {
         response = OpenStruct.new({
-          :body => http.response,
-          :headers => WebMock::Util::Headers.normalize_headers(extract_response_headers(http)),
-          :message => http.response_header.http_reason,
-          :status => http.response_header.status.to_s
+          body: http.response,
+          headers: WebMock::Util::Headers.normalize_headers(extract_response_headers(http)),
+          message: http.response_header.http_reason,
+          status: http.response_header.status.to_s
         })
         EventMachine.stop
       }
@@ -45,11 +50,11 @@ module EMHttpRequestSpecHelper
   end
 
   def client_timeout_exception_class
-    "WebMock timeout error"
+    'Errno::ETIMEDOUT'
   end
 
   def connection_refused_exception_class
-    ""
+    RuntimeError
   end
 
   def http_library

data/spec/acceptance/excon/excon_spec.rb

@@ -4,12 +4,74 @@ require 'acceptance/excon/excon_spec_helper'
 
 describe "Excon" do
   include ExconSpecHelper
-  include_context "with WebMock", :no_status_message, :no_url_auth
+  include_context "with WebMock", :no_url_auth
 
   it 'should allow Excon requests to use query hash paramters' do
-    stub_request(:get, "http://example.com/resource/?a=1&b=2").to_return(:body => "abc")
-    Excon.get('http://example.com', :path => "resource/", :query => {:a => 1, :b => 2}).body.should == "abc"
+    stub_request(:get, "http://example.com/resource/?a=1&b=2").to_return(body: "abc")
+    expect(Excon.new('http://example.com').get(path: "resource/", query: {a: 1, b: 2}).body).to eq("abc")
   end
 
-end
+  it 'should support Excon :expects options' do
+    stub_request(:get, "http://example.com/").to_return(body: 'a')
+    expect { Excon.new('http://example.com').get(expects: 204) }.to raise_error(Excon::Errors::OK)
+  end
+
+  context "with response_block" do
+    it "should support excon response_block for real requests", net_connect: true do
+      a = []
+      WebMock.allow_net_connect!
+      r = Excon.new('http://httpstat.us/200', headers: { "Accept" => "*" }).
+        get(response_block: lambda {|e, remaining, total| a << e}, chunk_size: 1)
+      expect(a).to eq(["2", "0", "0", " ", "O", "K"])
+      expect(r.body).to eq("")
+    end
+
+    it "should support excon response_block" do
+      a = []
+      stub_request(:get, "http://example.com/").to_return(body: "abc")
+      r = Excon.new('http://example.com').get(response_block: lambda {|e, remaining, total| a << e}, chunk_size: 1)
+      expect(a).to eq(['a', 'b', 'c'])
+      expect(r.body).to eq("")
+    end
+
+    it "should invoke callbacks with response body even if a real request is made", net_connect: true do
+      a = []
+      WebMock.allow_net_connect!
+      response = nil
+      WebMock.after_request { |_, res|
+        response = res
+      }
+      r = Excon.new('http://httpstat.us/200', headers: { "Accept" => "*" }).
+        get(response_block: lambda {|e, remaining, total| a << e}, chunk_size: 1)
+      expect(response.body).to eq("200 OK")
+      expect(a).to eq(["2", "0", "0", " ", "O", "K"])
+      expect(r.body).to eq("")
+    end
+  end
+
+  let(:file) { File.new(__FILE__) }
+  let(:file_contents) { File.read(__FILE__) }
+
+  it 'handles file uploads correctly' do
+    stub_request(:put, "http://example.com/upload").with(body: file_contents)
+
+    yielded_request_body = nil
+    WebMock.after_request do |req, res|
+      yielded_request_body = req.body
+    end
 
+    Excon.new("http://example.com").put(path: "upload", body: file)
+
+    expect(yielded_request_body).to eq(file_contents)
+  end
+
+  describe '.request_params_from' do
+
+    it 'rejects invalid request keys' do
+      request_params = WebMock::HttpLibAdapters::ExconAdapter.request_params_from(body: :keep, fake: :reject)
+      expect(request_params).to eq(body: :keep)
+    end
+
+  end
+
+end

data/spec/acceptance/excon/excon_spec_helper.rb

@@ -4,11 +4,23 @@ module ExconSpecHelper
 
   def http_request(method, uri, options = {}, &block)
     Excon.defaults[:ssl_verify_peer] = false
+    Excon.defaults[:ciphers] = 'DEFAULT'
     uri      = Addressable::URI.heuristic_parse(uri)
-    uri      = uri.omit(:userinfo).to_s.gsub(' ', '+')
+    uri      = uri.to_s.gsub(' ', '%20')
 
-    options  = options.merge(:method => method) # Dup and merge
-    response = Excon.new(uri).request(options, &block)
+    excon_options = {}
+
+    if basic_auth = options.delete(:basic_auth)
+      excon_options = {user: basic_auth[0], password: basic_auth[1]}
+    end
+
+    if Gem::Version.new(Excon::VERSION) < Gem::Version.new("0.29.0")
+      options  = options.merge(method: method, nonblock: false) # Dup and merge
+      response = Excon.new(uri, excon_options).request(options, &block)
+    else
+      options  = options.merge(method: method) # Dup and merge
+      response = Excon.new(uri, excon_options.merge(nonblock: false)).request(options, &block)
+    end
 
     headers  = WebMock::Util::Headers.normalize_headers(response.headers)
     headers  = headers.inject({}) do |res, (name, value)|
@@ -16,11 +28,13 @@ module ExconSpecHelper
       res
     end
 
+    Excon.set_raise_on_warnings!(true)
+
     OpenStruct.new \
-      :body => response.body,
-      :headers => headers,
-      :status  => response.status.to_s,
-      :message => ""
+      body: response.body,
+      headers: headers,
+      status: response.status.to_s,
+      message: response.reason_phrase
   end
 
   def client_timeout_exception_class