webmock 1.8.6 → 3.14.0

data/spec/acceptance/http_rb/http_rb_spec.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+require "spec_helper"
+require "acceptance/webmock_shared"
+require "acceptance/http_rb/http_rb_spec_helper"
+
+describe "HTTP.rb" do
+  include HttpRbSpecHelper
+
+  include_examples "with WebMock", :no_status_message
+
+  context "streaming body" do
+    let(:response) { HTTP.get "http://example.com" }
+    before { stub_simple_request "example.com", 302, {}, "abc" }
+
+    it "works as if it was streamed from socket" do
+      expect(response.body.readpartial 1).to eq "a"
+    end
+
+    it "fails if body was already streamed" do
+      response.body.to_s
+      expect { response.body.readpartial 1 }.to raise_error(HTTP::StateError)
+    end
+  end
+
+  context "without following redirects" do
+    let(:response) { http_request(:get, "http://example.com") }
+    let(:headers)  { response.headers }
+
+    it "stops on first request" do
+      stub_simple_request("example.com", 302, "Location" => "http://www.example.com")
+      stub_simple_request("www.example.com")
+
+      expect(headers).to include "Host" => "example.com"
+    end
+  end
+
+  context "following redirects" do
+    let(:options)  { { follow: true } }
+    let(:response) { http_request(:get, "http://example.com", options) }
+    let(:headers)  { response.headers }
+
+    it "returns response of destination" do
+      stub_simple_request("example.com", 302, "Location" => "http://www.example.com")
+      stub_simple_request("www.example.com")
+
+      expect(headers).to include "Host" => "www.example.com"
+    end
+  end
+
+  context "restored request uri on replayed response object" do
+    it "keeps non-default port" do
+      stub_request :get, "example.com:1234/foo"
+      response = HTTP.get "http://example.com:1234/foo"
+
+      expect(response.uri.to_s).to eq "http://example.com:1234/foo"
+    end
+
+    it "does not injects default port" do
+      stub_request :get, "example.com/foo"
+      response = HTTP.get "http://example.com/foo"
+
+      expect(response.uri.to_s).to eq "http://example.com/foo"
+    end
+
+    it "strips out default port even if it was explicitly given" do
+      stub_request :get, "example.com/foo"
+      response = HTTP.get "http://example.com:80/foo"
+
+      expect(response.uri.to_s).to eq "http://example.com/foo"
+    end
+  end
+
+  context "streamer" do
+    it "can be read to a provided buffer" do
+      stub_request(:get, "example.com/foo")
+        .to_return(status: 200, body: "Hello world! ")
+      response = HTTP.get "http://example.com/foo"
+
+      buffer = ""
+      response.body.readpartial(1024, buffer)
+
+      expect(buffer).to eq "Hello world! "
+    end
+
+    it "can be closed" do
+      stub_request :get, "example.com/foo"
+      response = HTTP.get "http://example.com/foo"
+
+      response.connection.close
+    end
+  end
+end

data/spec/acceptance/http_rb/http_rb_spec_helper.rb

@@ -0,0 +1,54 @@
+require "ostruct"
+
+module HttpRbSpecHelper
+  def http_request(method, uri, options = {})
+    chain = HTTP
+
+    if basic_auth = options.delete(:basic_auth)
+      chain = chain.basic_auth(user: basic_auth[0], pass: basic_auth[1])
+    end
+
+    ssl_ctx = OpenSSL::SSL::SSLContext.new
+    ssl_ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+    response = chain.request(method, normalize_uri(uri), options.merge(ssl_context: ssl_ctx))
+
+    OpenStruct.new({
+      body: response.body.to_s,
+      headers: normalize_headers(response.headers.to_h),
+      status: response.code.to_s,
+      message: response.reason
+    })
+  end
+
+  def client_timeout_exception_class
+    return Errno::ETIMEDOUT if HTTP::VERSION < "1.0.0"
+    HTTP::TimeoutError
+  end
+
+  def connection_refused_exception_class
+    return Errno::ECONNREFUSED if HTTP::VERSION < "1.0.0"
+    HTTP::ConnectionError
+  end
+
+  def http_library
+    :http_rb
+  end
+
+  def normalize_uri(uri)
+    Addressable::URI.heuristic_parse(uri).normalize.to_s
+  end
+
+  def normalize_headers(headers)
+    headers = Hash[headers.map { |k, v| [k, Array(v).join(", ")] }]
+    WebMock::Util::Headers.normalize_headers headers
+  end
+
+  def stub_simple_request(host, status = 200, headers = {}, body = nil)
+    stub_request(:any, host).to_return({
+      status: status,
+      headers: headers.merge({ "Host" => host }),
+      body: body
+    })
+  end
+end

data/spec/acceptance/httpclient/httpclient_spec.rb

@@ -8,25 +8,41 @@ describe "HTTPClient" do
   include HTTPClientSpecHelper
 
   before(:each) do
+    WebMock.reset_callbacks
     HTTPClientSpecHelper.async_mode = false
   end
 
   include_examples "with WebMock"
 
+  it "should raise a clearly readable error if request with multipart body is sent" do
+    stub_request(:post, 'www.example.com').with(body: {type: 'image'})
+
+    expect {
+      HTTPClient.new.post_content('www.example.com', type: 'image', file: File.new('spec/fixtures/test.txt'))
+    }.to raise_error(ArgumentError, "WebMock does not support matching body for multipart/form-data requests yet :(")
+  end
+
   it "should yield block on response if block provided" do
-    stub_request(:get, "www.example.com").to_return(:body => "abc")
+    stub_request(:get, "www.example.com").to_return(body: "abc")
     response_body = ""
     http_request(:get, "http://www.example.com/") do |body|
       response_body = body
     end
-    response_body.should == "abc"
+    expect(response_body).to eq("abc")
+  end
+
+  it "should not yield block on empty response if block provided" do
+    stub_request(:get, "www.example.com").to_return(body: "")
+    response_body = ""
+    http_request(:get, "http://www.example.com/"){ raise }
+    expect(response_body).to eq("")
   end
 
   it "should match requests if headers are the same  but in different order" do
-    stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]} )
-    http_request(
+    stub_request(:get, "www.example.com").with(headers: {"a" => ["b", "c"]} )
+    expect(http_request(
       :get, "http://www.example.com/",
-    :headers => {"a" => ["c", "b"]}).status.should == "200"
+    headers: {"a" => ["c", "b"]}).status).to eq("200")
   end
 
   describe "when using async requests" do
@@ -38,14 +54,50 @@ describe "HTTPClient" do
   end
 
   it "should work with get_content" do
-    stub_request(:get, 'www.example.com').to_return(:status => 200, :body => 'test', :headers => {})
-    str = ''
+    stub_request(:get, 'www.example.com').to_return(status: 200, body: 'test', headers: {})
+    str = ''.dup
     HTTPClient.get_content('www.example.com') do |content|
       str << content
     end
-    str.should == 'test'
+    expect(str).to eq('test')
+  end
+
+  it "should work via JSONClient subclass" do
+    stub_request(:get, 'www.example.com').to_return(
+      status: 200,
+      body: '{"test": "foo"}',
+      headers: {'Content-Type' => 'application/json'}
+    )
+    content = JSONClient.get('www.example.com').content
+    expect(content).to eq("test" => "foo")
+  end
+
+  context "multipart bodies" do
+    let(:header) {{
+        'Accept' => 'application/json',
+        'Content-Type' => 'multipart/form-data'
+    }}
+
+   let(:body) {[
+      {
+        'Content-Type' => 'application/json',
+        'Content-Disposition' => 'form-data',
+        :content => '{"foo": "bar", "baz": 2}'
+      }
+    ]}
+
+    let(:make_request) {HTTPClient.new.post("http://www.example.com", body: body, header: header)}
+
+    before do
+      stub_request(:post, "www.example.com")
+    end
+
+    it "should work with multipart bodies" do
+      make_request
+    end
   end
 
+
   context "Filters" do
     class Filter
       def filter_request(request)
@@ -60,17 +112,106 @@ describe "HTTPClient" do
     before do
       @client = HTTPClient.new
       @client.request_filter << Filter.new
-      stub_request(:get, 'www.example.com').with(:headers => {'Authorization' => 'Bearer 0123456789'})
+      stub_request(:get, 'www.example.com').with(headers: {'Authorization' => 'Bearer 0123456789'})
     end
 
     it "supports request filters" do
-      @client.request(:get, 'http://www.example.com/').status.should == 200
+      expect(@client.request(:get, 'http://www.example.com/').status).to eq(200)
     end
 
     it "supports response filters" do
       res = @client.request(:get, 'http://www.example.com/')
-      res.header['X-Powered-By'].first.should == 'webmock'
+      expect(res.header['X-Powered-By'].first).to eq('webmock')
     end
   end
 
+  context 'when a client instance is re-used for another identical request' do
+    let(:client) { HTTPClient.new }
+    let(:webmock_server_url) {"http://#{WebMockServer.instance.host_with_port}/"}
+
+    before { WebMock.allow_net_connect! }
+
+    it 'invokes the global_stub_request hook for each request' do
+      # Mock time to ensure that date headers match
+      now = Time.now
+      allow(Time).to receive(:now).and_return(now)
+
+      request_signatures = []
+      WebMock.globally_stub_request do |request_sig|
+        request_signatures << request_sig
+        nil # to let the request be made for real
+      end
+
+      http_request(:get, webmock_server_url, client: client, headers: { "Cookie" => "bar=; foo=" })
+
+      if defined? HTTP::CookieJar
+        http_request(:get, webmock_server_url, client: client, headers: { "Cookie" => "bar=; foo=" })
+      else
+        # If http-cookie is not present, then the cookie headers will saved between requests
+        http_request(:get, webmock_server_url, client: client)
+      end
+
+      expect(request_signatures.size).to eq(2)
+      # Verify the request signatures were identical as needed by this example
+      expect(request_signatures.first).to eq(request_signatures.last)
+    end
+  end
+
+  context 'session headers' do
+    it "client sends a User-Agent header when given an agent_name explicitly to the client" do
+      user_agent = "Client/0.1"
+      stub_request(:get, "www.example.com").with(headers: { 'User-agent' => "#{user_agent} #{HTTPClient::LIB_NAME}" })
+      HTTPClient.new(agent_name: user_agent).get("www.example.com")
+    end
+
+    it "client sends the Accept, User-Agent, and Date by default" do
+      WebMock.disable_net_connect!
+      stub_request(:get, "www.example.com").with do |req|
+        req.headers["Accept"] == "*/*" &&
+        req.headers["User-Agent"] == "#{HTTPClient::DEFAULT_AGENT_NAME} #{HTTPClient::LIB_NAME}" &&
+        req.headers["Date"]
+      end
+      http_request(:get, "www.example.com")
+    end
+
+    it "explicitly defined headers take precedence over session defaults" do
+      headers = { 'Accept'  => 'foo/bar', 'User-Agent' => 'custom', 'Date' => 'today' }
+      stub_request(:get, "www.example.com").with(headers: headers)
+      HTTPClient.new.get("www.example.com", nil, headers)
+    end
+  end
+
+  context 'httpclient response header' do
+    it 'receives request_method, request_uri, and request_query from the request header' do
+      stub_request :get, 'www.example.com'
+      message = HTTPClient.new.get 'www.example.com'
+      expect(message.header.request_uri.to_s).to eq('www.example.com')
+    end
+  end
+
+  context 'httpclient streams response', net_connect: true do
+    before do
+      WebMock.allow_net_connect!
+      WebMock.after_request(except: [:other_lib])  do |_, response|
+        @response = response
+      end
+    end
+
+    it 'sets the full body on the webmock response' do
+      body = ''
+      HTTPClient.new.request(:get, 'http://www.example.com/') do |http_res, chunk|
+        body += chunk
+      end
+      expect(@response.body).to eq body
+    end
+  end
+
+  context 'credentials' do
+    it 'are detected when manually specifying Authorization header' do
+      stub_request(:get, "http://www.example.com/").with(basic_auth: ['username', 'password']).to_return(status: 200)
+
+      headers = {'Authorization' => 'Basic dXNlcm5hbWU6cGFzc3dvcmQ='}
+      expect(http_request(:get, 'http://www.example.com/', {headers: headers}).status).to eql('200')
+    end
+  end
 end

data/spec/acceptance/httpclient/httpclient_spec_helper.rb

@@ -5,11 +5,15 @@ module HTTPClientSpecHelper
 
   def http_request(method, uri, options = {}, &block)
     uri = Addressable::URI.heuristic_parse(uri)
-    c = HTTPClient.new
+    c = options.fetch(:client) { HTTPClient.new }
     c.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    c.set_basic_auth(nil, uri.user, uri.password) if uri.user
-    params = [method, "#{uri.omit(:userinfo, :query).normalize.to_s}",
-      uri.query_values, options[:body], options[:headers] || {}]
+    c.reset_all
+    if options[:basic_auth]
+      c.force_basic_auth = true
+      c.set_basic_auth(nil, options[:basic_auth][0], options[:basic_auth][1])
+    end
+    params = [method, uri.normalize.to_s,
+      WebMock::Util::QueryMapper.query_to_values(uri.query, notation: WebMock::Config.instance.query_values_notation), options[:body], options[:headers] || {}]
     if HTTPClientSpecHelper.async_mode
       connection = c.request_async(*params)
       connection.join
@@ -17,19 +21,12 @@ module HTTPClientSpecHelper
     else
       response = c.request(*params, &block)
     end
-    headers = response.header.all.inject({}) do |headers, header|
-      if !headers.has_key?(header[0])
-        headers[header[0]] = header[1]
-      else
-        headers[header[0]] = [headers[header[0]], header[1]].join(', ')
-      end
-      headers
-    end
+    headers = merge_headers(response)
     OpenStruct.new({
-      :body => HTTPClientSpecHelper.async_mode ? response.content.read : response.content,
-      :headers => headers,
-      :status => response.code.to_s,
-      :message => response.reason
+      body: HTTPClientSpecHelper.async_mode ? response.content.read : response.content,
+      headers: headers,
+      status: response.code.to_s,
+      message: response.reason
     })
   end
 
@@ -45,4 +42,16 @@ module HTTPClientSpecHelper
     :httpclient
   end
 
+private
+
+  def merge_headers(response)
+    response.header.all.inject({}) do |headers, header|
+      if !headers.has_key?(header[0])
+        headers[header[0]] = header[1]
+      else
+        headers[header[0]] = [headers[header[0]], header[1]].join(', ')
+      end
+      headers
+    end
+  end
 end

data/spec/acceptance/manticore/manticore_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+
+if RUBY_PLATFORM =~ /java/
+  require 'acceptance/manticore/manticore_spec_helper'
+
+  describe "Manticore" do
+    include ManticoreSpecHelper
+
+    include_context "with WebMock", :no_status_message
+
+    context "calling http methods on Manticore directly using Manticore's facade" do
+      it "handles GET" do
+        stub_request(:get, "http://example-foo.com").to_return(status: 301)
+        response = Manticore.get("http://example-foo.com")
+        expect(response.code).to eq(301)
+      end
+
+      it "handles POST" do
+        stub_request(:post, "http://example-foo.com").to_return(status: 201)
+        response = Manticore.post("http://example-foo.com", {hello: "world"})
+        expect(response.code).to eq(201)
+      end
+
+      it "handles PUT" do
+        stub_request(:put, "http://example-foo.com").to_return(status: 409)
+        response = Manticore.put("http://example-foo.com", {hello: "world"})
+        expect(response.code).to eq(409)
+      end
+
+      it "handles PATCH" do
+        stub_request(:patch, "http://example-foo.com").to_return(status: 409)
+        response = Manticore.patch("http://example-foo.com", {hello: "world"})
+        expect(response.code).to eq(409)
+      end
+
+      it "handles DELETE" do
+        stub_request(:delete, "http://example-foo.com").to_return(status: 204)
+        response = Manticore.delete("http://example-foo.com", {id: 1})
+        expect(response.code).to eq(204)
+      end
+
+      it "handles OPTIONS" do
+        stub_request(:options, "http://example-foo.com").to_return(status: 200)
+        response = Manticore.options("http://example-foo.com")
+        expect(response.code).to eq(200)
+      end
+
+      it "handles HEAD" do
+        stub_request(:head, "http://example-foo.com").to_return(status: 204)
+        response = Manticore.head("http://example-foo.com")
+        expect(response.code).to eq(204)
+      end
+
+      context "when a custom failure handler is defined" do
+        let(:failure_handler) { proc {} }
+
+        before do
+          allow(failure_handler).to receive(:call).with(kind_of(Manticore::Timeout)) do |ex|
+            raise ex
+          end
+        end
+
+        it "handles timeouts by invoking the failure handler" do
+          stub_request(:get, "http://example-foo.com").to_timeout
+          request = Manticore.get("http://example-foo.com").tap do |req|
+            req.on_failure(&failure_handler)
+          end
+          expect { request.call }.to raise_error(Manticore::Timeout)
+          expect(failure_handler).to have_received(:call)
+        end
+      end
+
+      context 'when used in a streaming mode' do
+        let(:webmock_server_url) {"http://#{WebMockServer.instance.host_with_port}/"}
+        let(:result_chunks) { [] }
+
+        def manticore_streaming_get
+          Manticore.get(webmock_server_url).tap do |req|
+            req.on_success do |response|
+              response.body do |chunk|
+                result_chunks << chunk
+              end
+            end
+          end
+        end
+
+        context 'when connections are allowed' do
+          it 'works' do
+            WebMock.allow_net_connect!
+            expect { manticore_streaming_get.call }.to_not raise_error
+            expect(result_chunks).to_not be_empty
+          end
+        end
+
+        context 'when stubbed' do
+          it 'works' do
+            stub_body = 'hello!'
+            stub_request(:get, webmock_server_url).to_return(body: stub_body)
+            expect { manticore_streaming_get.call }.to_not raise_error
+            expect(result_chunks).to eq [stub_body]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/manticore/manticore_spec_helper.rb

@@ -0,0 +1,35 @@
+module ManticoreSpecHelper
+  def http_request(method, uri, options = {})
+    client = Manticore::Client.new
+
+    if basic_auth = options[:basic_auth]
+      options = options.merge(auth: {user: basic_auth[0], pass: basic_auth[1]})
+    end
+
+    response = client.http(method, uri, options)
+    OpenStruct.new({
+      body: response.body || '',
+      headers: WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),
+      status: response.code.to_s
+    })
+  end
+
+  def join_array_values(hash)
+    hash.reduce({}) do |h, (k,v)|
+      v = v.join(', ') if v.is_a?(Array)
+      h.merge(k => v)
+    end
+  end
+
+  def client_timeout_exception_class
+    Manticore::ConnectTimeout
+  end
+
+  def connection_refused_exception_class
+    Manticore::SocketException
+  end
+
+  def http_library
+    :manticore
+  end
+end