logstash-output-scalyr 0.1.10.beta → 0.1.11.beta

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/spec/acceptance/httpclient/httpclient_spec_helper.rb

@@ -0,0 +1,57 @@
+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/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/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/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/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

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/spec/acceptance/net_http/net_http_shared.rb

@@ -0,0 +1,153 @@
+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 = "".dup
+      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

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/spec/acceptance/net_http/net_http_spec.rb

@@ -0,0 +1,369 @@
+require 'spec_helper'
+require 'ostruct'
+require 'acceptance/webmock_shared'
+require 'acceptance/net_http/net_http_spec_helper'
+require 'acceptance/net_http/net_http_shared'
+
+include NetHTTPSpecHelper
+
+describe "Net:HTTP" do
+  include_examples "with WebMock", :no_url_auth
+
+  let(:port) { WebMockServer.instance.port }
+
+  describe "marshalling" do
+    class TestMarshalingInWebMockNetHTTP
+      attr_accessor :r
+    end
+    before(:each) do
+      @b = TestMarshalingInWebMockNetHTTP.new
+    end
+    after(:each) do
+      WebMock.enable!
+    end
+    it "should be possible to load object marshalled when webmock was disabled" do
+      WebMock.disable!
+      original_constants = [
+        Net::HTTP::Get,
+        Net::HTTP::Post,
+        Net::HTTP::Put,
+        Net::HTTP::Delete,
+        Net::HTTP::Head,
+        Net::HTTP::Options
+      ]
+      @b.r = original_constants
+      original_serialized = Marshal.dump(@b)
+      Marshal.load(original_serialized)
+      WebMock.enable!
+      Marshal.load(original_serialized)
+    end
+
+    it "should be possible to load object marshalled when webmock was enabled"  do
+      WebMock.enable!
+      new_constants = [
+        Net::HTTP::Get,
+        Net::HTTP::Post,
+        Net::HTTP::Put,
+        Net::HTTP::Delete,
+        Net::HTTP::Head,
+        Net::HTTP::Options
+      ]
+      @b.r = new_constants
+      new_serialized = Marshal.dump(@b)
+      Marshal.load(new_serialized)
+      WebMock.disable!
+      Marshal.load(new_serialized)
+    end
+  end
+
+  describe "constants" do
+    it "should still have const Get defined on replaced Net::HTTP" do
+      expect(Object.const_get("Net").const_get("HTTP").const_defined?("Get")).to be_truthy
+    end
+
+    it "should still have const Get within constants on replaced Net::HTTP" do
+      expect(Object.const_get("Net").const_get("HTTP").constants.map(&:to_s)).to include("Get")
+    end
+
+    it "should still have const Get within constants on replaced Net::HTTP" do
+      expect(Object.const_get("Net").const_get("HTTP").const_get("Get")).not_to be_nil
+    end
+
+    if Module.method(:const_defined?).arity != 1
+      it "should still have const Get defined (and not inherited) on replaced Net::HTTP" do
+        expect(Object.const_get("Net").const_get("HTTP").const_defined?("Get", false)).to be_truthy
+      end
+    end
+
+    if Module.method(:const_get).arity != 1
+      it "should still be able to get non inherited constant Get on replaced Net::HTTP" do
+        expect(Object.const_get("Net").const_get("HTTP").const_get("Get", false)).not_to be_nil
+      end
+    end
+
+    if Module.method(:constants).arity != 0
+      it "should still Get within non inherited constants on replaced Net::HTTP" do
+        expect(Object.const_get("Net").const_get("HTTP").constants(false).map(&:to_s)).to include("Get")
+      end
+    end
+
+    describe "after WebMock is disabled" do
+      after(:each) do
+        WebMock.enable!
+      end
+      it "Net::HTTP should have the same constants" do
+        orig_consts_number = WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP.constants.size
+        Net::HTTP.send(:const_set, "TEST_CONST", 10)
+        expect(Net::HTTP.constants.size).to eq(orig_consts_number + 1)
+        WebMock.disable!
+        expect(Net::HTTP.constants.size).to eq(orig_consts_number + 1)
+      end
+    end
+  end
+
+  it "should work with block provided" do
+    stub_http_request(:get, "www.example.com").to_return(body: "abc"*100000)
+    expect(Net::HTTP.start("www.example.com") { |query| query.get("/") }.body).to eq("abc"*100000)
+  end
+
+  it "should handle requests with raw binary data" do
+    body = "\x14\x00\x00\x00\x70\x69\x6e\x67\x00\x00"
+    stub_http_request(:post, "www.example.com").with(body: body).to_return(body: "abc")
+    req = Net::HTTP::Post.new("/")
+    req.body = body
+    req.content_type = "application/octet-stream"
+    expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
+  end
+
+  it "raises an ArgumentError if passed headers as symbols if RUBY_VERSION < 2.3.0" do
+    uri = URI.parse("http://google.com/")
+    http = Net::HTTP.new(uri.host, uri.port)
+    request = Net::HTTP::Get.new(uri.request_uri)
+
+    # Net::HTTP calls downcase on header keys assigned with []=
+    # In Ruby 1.8.7 symbols do not respond to downcase
+    #
+    # Meaning you can not assign header keys as symbols in ruby 1.8.7 using []=
+    if :symbol.respond_to?(:downcase)
+      request[:InvalidHeaderSinceItsASymbol] = "this will not be valid"
+    else
+      request.instance_eval do
+        @header = request.to_hash.merge({InvalidHeaderSinceItsASymbol: "this will not be valid"})
+      end
+    end
+
+    if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.3.0')
+      expect do
+        http.request(request)
+      end.to raise_error ArgumentError, "Net:HTTP does not accept headers as symbols"
+    else
+      stub_http_request(:get, "google.com").with(headers: { InvalidHeaderSinceItsASymbol: "this will not be valid" })
+      expect do
+        http.request(request)
+      end.not_to raise_error
+    end
+  end
+
+  it "should handle multiple values for the same response header" do
+    stub_http_request(:get, "www.example.com").to_return(headers: { 'Set-Cookie' => ['foo=bar', 'bar=bazz'] })
+    response = Net::HTTP.get_response(URI.parse("http://www.example.com/"))
+    expect(response.get_fields('Set-Cookie')).to eq(['bar=bazz', 'foo=bar'])
+  end
+
+  it "should yield block on response" do
+    stub_http_request(:get, "www.example.com").to_return(body: "abc")
+    response_body = ""
+    http_request(:get, "http://www.example.com/") do |response|
+      response_body = response.body
+    end
+    expect(response_body).to eq("abc")
+  end
+
+  it "should handle Net::HTTP::Post#body" do
+    stub_http_request(:post, "www.example.com").with(body: "my_params").to_return(body: "abc")
+    req = Net::HTTP::Post.new("/")
+    req.body = "my_params"
+    expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
+  end
+
+  it "should handle Net::HTTP::Post#body_stream" do
+    stub_http_request(:post, "www.example.com").with(body: "my_params").to_return(body: "abc")
+    req = Net::HTTP::Post.new("/")
+    req.body_stream = StringIO.new("my_params")
+    expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
+  end
+
+  it "should behave like Net::HTTP and raise error if both request body and body argument are set" do
+    stub_http_request(:post, "www.example.com").with(body: "my_params").to_return(body: "abc")
+    req = Net::HTTP::Post.new("/")
+    req.body = "my_params"
+    expect {
+      Net::HTTP.start("www.example.com") { |http| http.request(req, "my_params")}
+    }.to raise_error("both of body argument and HTTPRequest#body set")
+  end
+
+  it "should return a Net::ReadAdapter from response.body when a stubbed request is made with a block and #read_body" do
+    WebMock.stub_request(:get, 'http://example.com/').to_return(body: "the body")
+    response = Net::HTTP.new('example.com', 80).request_get('/') { |r| r.read_body { } }
+    expect(response.body).to be_a(Net::ReadAdapter)
+  end
+
+  it "should have request 1 time executed in registry after 1 real request", net_connect: true do
+    WebMock.allow_net_connect!
+    http = Net::HTTP.new('localhost', port)
+    http.get('/') {}
+    expect(WebMock::RequestRegistry.instance.requested_signatures.hash.size).to eq(1)
+    expect(WebMock::RequestRegistry.instance.requested_signatures.hash.values.first).to eq(1)
+  end
+
+  it "should work with Addressable::URI passed to Net::HTTP.get_response" do
+    stub_request(:get, 'http://www.example.com/hello?a=1').to_return(body: "abc")
+    expect(Net::HTTP.get_response(Addressable::URI.parse('http://www.example.com/hello?a=1')).body).to eq("abc")
+  end
+
+  it "should support method calls on stubbed socket" do
+    WebMock.allow_net_connect!
+    stub_request(:get, 'www.google.com')#.with(headers: {"My-Header" => 99})
+    req = Net::HTTP::Get.new('/')
+    Net::HTTP.start('www.google.com') do |http|
+      http.request(req, '')
+      socket = http.instance_variable_get(:@socket)
+      expect(socket).to be_a(StubSocket)
+      expect { socket.io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) }.to_not raise_error
+    end
+  end
+
+  describe "connecting on Net::HTTP.start" do
+    before(:each) do
+      @http = Net::HTTP.new('www.google.com', 443)
+      @http.use_ssl = true
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    describe "when net http is allowed" do
+      it "should not connect to the server until the request", net_connect: true do
+        WebMock.allow_net_connect!
+        @http.start {|conn|
+          expect(conn.peer_cert).to be_nil
+        }
+      end
+
+      it "should connect to the server on start", net_connect: true do
+        WebMock.allow_net_connect!(net_http_connect_on_start: true)
+        @http.start {|conn|
+          cert = OpenSSL::X509::Certificate.new conn.peer_cert
+          expect(cert).to be_a(OpenSSL::X509::Certificate)
+        }
+      end
+
+    end
+
+    describe "when net http is disabled and allowed only for some hosts" do
+      it "should not connect to the server until the request", net_connect: true do
+        WebMock.disable_net_connect!(allow: "www.google.com")
+        @http.start {|conn|
+          expect(conn.peer_cert).to be_nil
+        }
+      end
+
+      it "should connect to the server on start", net_connect: true do
+        WebMock.disable_net_connect!(allow: "www.google.com", net_http_connect_on_start: true)
+        @http.start {|conn|
+          cert = OpenSSL::X509::Certificate.new conn.peer_cert
+          expect(cert).to be_a(OpenSSL::X509::Certificate)
+        }
+      end
+
+      it "should connect to the server if the URI matches an regex", net_connect: true do
+        WebMock.disable_net_connect!(allow: /google.com/)
+        Net::HTTP.get('www.google.com','/')
+      end
+
+      it "should connect to the server if the URI matches any regex the array", net_connect: true do
+        WebMock.disable_net_connect!(allow: [/google.com/, /yahoo.com/])
+        Net::HTTP.get('www.google.com','/')
+      end
+
+    end
+
+  end
+
+  describe "when net_http_connect_on_start is true" do
+    before(:each) do
+      WebMock.allow_net_connect!(net_http_connect_on_start: true)
+    end
+    it_should_behave_like "Net::HTTP"
+  end
+
+  describe "when net_http_connect_on_start is false" do
+    before(:each) do
+      WebMock.allow_net_connect!(net_http_connect_on_start: false)
+    end
+    it_should_behave_like "Net::HTTP"
+  end
+
+  describe 'after_request callback support', net_connect: true do
+    let(:expected_body_regex) { /hello world/ }
+
+    before(:each) do
+      WebMock.allow_net_connect!
+      @callback_invocation_count = 0
+      WebMock.after_request do |_, response|
+        @callback_invocation_count += 1
+        @callback_response = response
+      end
+    end
+
+    after(:each) do
+      WebMock.reset_callbacks
+    end
+
+    def perform_get_with_returning_block
+      http_request(:get, "http://localhost:#{port}/") do |response|
+        return response.body
+      end
+    end
+
+    it "should support the after_request callback on an request with block and read_body" do
+      response_body = ''.dup
+      http_request(:get, "http://localhost:#{port}/") do |response|
+        response.read_body { |fragment| response_body << fragment }
+      end
+      expect(response_body).to match(expected_body_regex)
+
+      expect(@callback_response.body).to eq(response_body)
+    end
+
+    it "should support the after_request callback on a request with a returning block" do
+      response_body = perform_get_with_returning_block
+      expect(response_body).to match(expected_body_regex)
+      expect(@callback_response).to be_instance_of(WebMock::Response)
+      expect(@callback_response.body).to eq(response_body)
+    end
+
+    it "should only invoke the after_request callback once, even for a recursive post request" do
+      Net::HTTP.new('localhost', port).post('/', nil)
+      expect(@callback_invocation_count).to eq(1)
+    end
+  end
+
+  it "should match http headers, even if their values have been set in a request as numbers" do
+    WebMock.disable_net_connect!
+
+    stub_request(:post, "www.example.com").with(headers: {"My-Header" => 99})
+
+    uri = URI.parse('http://www.example.com/')
+    req = Net::HTTP::Post.new(uri.path)
+    req['My-Header'] = 99
+
+    res = Net::HTTP.start(uri.host, uri.port) do |http|
+      http.request(req, '')
+    end
+  end
+
+  describe "hostname handling" do
+    it "should set brackets around the hostname if it is an IPv6 address" do
+      net_http = Net::HTTP.new('b2dc:5bdf:4f0d::3014:e0ca', 80)
+      path = '/example.jpg'
+      expect(WebMock::NetHTTPUtility.get_uri(net_http, path)).to eq('http://[b2dc:5bdf:4f0d::3014:e0ca]:80/example.jpg')
+    end
+
+    it "should not set brackets around the hostname if it is already wrapped by brackets" do
+      net_http = Net::HTTP.new('[b2dc:5bdf:4f0d::3014:e0ca]', 80)
+      path = '/example.jpg'
+      expect(WebMock::NetHTTPUtility.get_uri(net_http, path)).to eq('http://[b2dc:5bdf:4f0d::3014:e0ca]:80/example.jpg')
+    end
+
+    it "should not set brackets around the hostname if it is an IPv4 address" do
+      net_http = Net::HTTP.new('181.152.137.168', 80)
+      path = '/example.jpg'
+      expect(WebMock::NetHTTPUtility.get_uri(net_http, path)).to eq('http://181.152.137.168:80/example.jpg')
+    end
+
+    it "should not set brackets around the hostname if it is a domain" do
+      net_http = Net::HTTP.new('www.example.com', 80)
+      path = '/example.jpg'
+      expect(WebMock::NetHTTPUtility.get_uri(net_http, path)).to eq('http://www.example.com:80/example.jpg')
+    end
+  end
+end