webmock 3.18.1 → 3.19.0

data/spec/acceptance/http_rb/http_rb_spec.rb

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

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

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

data/spec/acceptance/httpclient/httpclient_spec_helper.rb

@@ -1,57 +0,0 @@
-module HTTPClientSpecHelper
-  class << self
-    attr_accessor :async_mode
-  end
-
-  def http_request(method, uri, options = {}, &block)
-    uri = Addressable::URI.heuristic_parse(uri)
-    c = options.fetch(:client) { HTTPClient.new }
-    c.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    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
-      response = connection.pop
-    else
-      response = c.request(*params, &block)
-    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
-    })
-  end
-
-  def client_timeout_exception_class
-    HTTPClient::TimeoutError
-  end
-
-  def connection_refused_exception_class
-    Errno::ECONNREFUSED
-  end
-
-  def http_library
-    :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

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

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