webmock 3.7.1

data/spec/acceptance/em_http_request/em_http_request_spec_helper.rb

@@ -0,0 +1,77 @@
+module EMHttpRequestSpecHelper
+
+  def failed
+    EventMachine.stop
+    fail
+  end
+
+  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
+    uri = Addressable::URI.heuristic_parse(uri)
+    EventMachine.run {
+      request = EventMachine::HttpRequest.new("#{uri.normalize.to_s}")
+      http = request.send(method, {
+        timeout: 30,
+        body: options[:body],
+        file: options[:file],
+        query: options[:query],
+        head: head,
+        compressed: false
+      }, &block)
+      http.errback {
+        error_set = true
+        error = if http.respond_to?(:errors)
+          http.errors
+        else
+          http.error
+        end
+        failed
+      }
+      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
+        })
+        EventMachine.stop
+      }
+      @http = http
+    }
+    raise error.to_s if error_set
+    response
+  end
+
+  def client_timeout_exception_class
+    "WebMock timeout error"
+  end
+
+  def connection_refused_exception_class
+    RuntimeError
+  end
+
+  def http_library
+    :em_http_request
+  end
+
+  private
+
+  def extract_response_headers(http)
+    headers = {}
+    if http.response_header
+      http.response_header.each do |k,v|
+        v = v.join(", ") if v.is_a?(Array)
+        headers[k] = v
+      end
+    end
+    headers
+  end
+
+end

data/spec/acceptance/excon/excon_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+require 'acceptance/excon/excon_spec_helper'
+
+describe "Excon" do
+  include ExconSpecHelper
+  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")
+    expect(Excon.new('http://example.com').get(path: "resource/", query: {a: 1, b: 2}).body).to eq("abc")
+  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

@@ -0,0 +1,50 @@
+require 'ostruct'
+
+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.to_s.gsub(' ', '%20')
+
+    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)|
+      res[name] = value.is_a?(Array) ? value.flatten.join(', ') : value
+      res
+    end
+
+    OpenStruct.new \
+      body: response.body,
+      headers: headers,
+      status: response.status.to_s,
+      message: response.reason_phrase
+  end
+
+  def client_timeout_exception_class
+    Excon::Errors::Timeout
+  end
+
+  def connection_refused_exception_class
+    Excon::Errors::SocketError
+  end
+
+  def http_library
+    :excon
+  end
+
+end

data/spec/acceptance/http_rb/http_rb_spec.rb

@@ -0,0 +1,82 @@
+# 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 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

@@ -0,0 +1,217 @@
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+require 'ostruct'
+
+require 'acceptance/httpclient/httpclient_spec_helper'
+
+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")
+    response_body = ""
+    http_request(:get, "http://www.example.com/") do |body|
+      response_body = body
+    end
+    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"]} )
+    expect(http_request(
+      :get, "http://www.example.com/",
+    headers: {"a" => ["c", "b"]}).status).to eq("200")
+  end
+
+  describe "when using async requests" do
+    before(:each) do
+      HTTPClientSpecHelper.async_mode = true
+    end
+
+    include_examples "with WebMock"
+  end
+
+  it "should work with get_content" do
+    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
+    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)
+        request.header["Authorization"] = "Bearer 0123456789"
+      end
+
+      def filter_response(request, response)
+        response.header.set('X-Powered-By', 'webmock')
+      end
+    end
+
+    before do
+      @client = HTTPClient.new
+      @client.request_filter << Filter.new
+      stub_request(:get, 'www.example.com').with(headers: {'Authorization' => 'Bearer 0123456789'})
+    end
+
+    it "supports request filters" do
+      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/')
+      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