webmock 3.0.1 → 3.20.0

data/spec/acceptance/http_rb/http_rb_spec_helper.rb

@@ -1,51 +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
-
-    response = chain.request(method, normalize_uri(uri), options)
-
-    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::ConnectionError
-  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,210 +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 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 = ''
-    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,56 +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
-    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

data/spec/acceptance/net_http/net_http_shared.rb

@@ -1,153 +0,0 @@
-shared_examples_for "Net::HTTP" do
-  describe "when making real requests", net_connect: true do
-    let(:port){ WebMockServer.instance.port }
-
-    before(:each) do
-      @http = Net::HTTP.new("localhost", port)
-    end
-
-    it "should return a Net::ReadAdapter from response.body when a real request is made with a block and #read_body", net_connect: true do
-      response = Net::HTTP.new("localhost", port).request_get('/') { |r| r.read_body { } }
-      expect(response.body).to be_a(Net::ReadAdapter)
-    end
-
-    it "should handle requests with block passed to read_body", net_connect: true do
-      body = ""
-      req = Net::HTTP::Get.new("/")
-      Net::HTTP.start("localhost", port) do |http|
-        http.request(req) do |res|
-          res.read_body do |str|
-            body << str
-          end
-        end
-      end
-      expect(body).to match(/hello world/)
-    end
-
-    it "should connect only once when connected on start", net_connect: true do
-      @http = Net::HTTP.new('localhost', port)
-      socket_id_before_request = socket_id_after_request = nil
-      @http.start {|conn|
-        socket_id_before_request = conn.instance_variable_get(:@socket).object_id
-        conn.request(Net::HTTP::Get.new("/"))
-        socket_id_after_request = conn.instance_variable_get(:@socket).object_id
-      }
-
-      if !defined?(WebMock::Config) || WebMock::Config.instance.net_http_connect_on_start
-        expect(socket_id_before_request).not_to eq(nil.object_id)
-        expect(socket_id_after_request).not_to eq(nil.object_id)
-        expect(socket_id_after_request).to eq(socket_id_before_request)
-      else
-        expect(socket_id_before_request).to eq(nil.object_id)
-        expect(socket_id_after_request).not_to eq(nil.object_id)
-      end
-    end
-
-    it "should pass the read_timeout value on", net_connect: true do
-      @http = Net::HTTP.new('localhost', port)
-      read_timeout = @http.read_timeout + 1
-      @http.read_timeout = read_timeout
-      @http.start {|conn|
-        conn.request(Net::HTTP::Get.new("/"))
-        socket = conn.instance_variable_get(:@socket)
-        expect(socket.read_timeout).to eq(read_timeout)
-      }
-    end
-
-    describe "without start" do
-      it "should close connection after a real request" do
-        @http.get('/') { }
-        expect(@http).not_to be_started
-      end
-
-      it "should execute block exactly once" do
-        times = 0
-        @http.get('/') { times += 1 }
-        expect(times).to eq(1)
-      end
-
-      it "should have socket open during a real request" do
-        socket_id = nil
-        @http.get('/') {
-          socket_id = @http.instance_variable_get(:@socket).object_id
-        }
-        expect(socket_id).not_to be_nil
-      end
-
-      it "should be started during a real request" do
-        started = nil
-        @http.get('/') {
-          started = @http.started?
-        }
-        expect(started).to eq(true)
-        expect(@http.started?).to eq(false)
-      end
-    end
-
-    describe "with start" do
-      it "should close connection after a real request" do
-        @http.start {|conn| conn.get('/') { } }
-        expect(@http).not_to be_started
-      end
-
-      it "should execute block exactly once" do
-        times = 0
-        @http.start {|conn| conn.get('/') { times += 1 }}
-        expect(times).to eq(1)
-      end
-
-      it "should have socket open during a real request" do
-        socket_id = nil
-        @http.start {|conn| conn.get('/') {
-            socket_id = conn.instance_variable_get(:@socket).object_id
-          }
-        }
-        expect(socket_id).not_to be_nil
-      end
-
-      it "should be started during a real request" do
-        started = nil
-        @http.start {|conn| conn.get('/') {
-            started = conn.started?
-          }
-        }
-        expect(started).to eq(true)
-        expect(@http.started?).to eq(false)
-      end
-    end
-
-    describe "with start without request block" do
-      it "should close connection after a real request" do
-        @http.start {|conn| conn.get('/') }
-        expect(@http).not_to be_started
-      end
-
-      it "should have socket open during a real request" do
-        socket_id = nil
-        @http.start {|conn|
-          socket_id = conn.instance_variable_get(:@socket).object_id
-        }
-        expect(socket_id).not_to be_nil
-      end
-
-      it "should be started during a real request" do
-        started = nil
-        @http.start {|conn|
-          started = conn.started?
-        }
-        expect(started).to eq(true)
-        expect(@http.started?).to eq(false)
-      end
-    end
-
-    describe "with start without a block and finish" do
-      it "should gracefully start and close connection" do
-        @http.start
-        @http.get("/")
-        expect(@http).to be_started
-        @http.finish
-        expect(@http).not_to be_started
-      end
-    end
-  end
-end