puppet 4.0.0 → 5.0.0

data/spec/unit/network/http/api/master/v3_spec.rb

@@ -1,8 +1,11 @@
 require 'spec_helper'
 
 require 'puppet/network/http'
+require 'puppet_spec/network'
 
 describe Puppet::Network::HTTP::API::Master::V3 do
+  include PuppetSpec::Network
+
   let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
   let(:master_url_prefix) { "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3" }
   let(:master_routes) {
@@ -19,21 +22,36 @@ describe Puppet::Network::HTTP::API::Master::V3 do
     expect(response.code).to eq(200)
   end
 
+  it "mounts the environment endpoint" do
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/environment/production")
+    master_routes.process(request, response)
+
+    expect(response.code).to eq(200)
+  end
+
+  it "matches only complete routes" do
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/foo/environments")
+    expect { master_routes.process(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
+
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/foo/environment/production")
+    expect { master_routes.process(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
+  end
+
   it "mounts indirected routes" do
     request = Puppet::Network::HTTP::Request.
         from_hash(:path => "#{master_url_prefix}/node/foo",
                   :params => {:environment => "production"},
-                  :headers => {"accept" => "text/pson"})
+                  :headers => {"accept" => "application/json"})
     master_routes.process(request, response)
 
     expect(response.code).to eq(200)
   end
 
-  it "responds to unknown paths with a 404" do
+  it "responds to unknown paths by raising not_found_error" do
     request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/unknown")
-    master_routes.process(request, response)
 
-    expect(response.code).to eq(404)
-    expect(response.body).to match("Not Found: Could not find indirection 'unknown'")
+    expect {
+      master_routes.process(request, response)
+    }.to raise_error(not_found_error)
   end
 end

data/spec/unit/network/http/api_spec.rb

@@ -79,7 +79,7 @@ describe Puppet::Network::HTTP::API do
       it "responds to v3 indirector requests" do
         req = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_prefix}/v3/node/foo",
                                                        :params => {:environment => "production"},
-                                                       :headers => {'accept' => "pson"})
+                                                       :headers => {'accept' => "application/json"})
         res = {}
         handler.process(req, res)
         expect(res[:status]).to eq(200)

data/spec/unit/network/http/compression_spec.rb

@@ -2,6 +2,20 @@
 require 'spec_helper'
 
 describe "http compression" do
+  let(:data)            { "uncompresseddata" }
+  let(:response)        { stub 'response' }
+  let(:compressed_zlib) { Zlib::Deflate.deflate(data) }
+  let(:compressed_gzip) do
+    str = StringIO.new
+    writer = Zlib::GzipWriter.new(str)
+    writer.write(data)
+    writer.close.string
+  end
+
+  def stubs_response_with(response, content_encoding, body)
+    response.stubs(:[]).with('content-encoding').returns(content_encoding)
+    response.stubs(:body).returns(body)
+  end
 
   describe "when zlib is not available" do
     before(:each) do
@@ -24,8 +38,8 @@ describe "http compression" do
     end
 
     it "should not tamper the body" do
-      response = stub 'response', :body => "data"
-      expect(@uncompressor.uncompress_body(response)).to eq("data")
+      response = stub 'response', :body => data
+      expect(@uncompressor.uncompress_body(response)).to eq(data)
     end
 
     it "should yield an identity uncompressor" do
@@ -37,23 +51,19 @@ describe "http compression" do
   end
 
   describe "when zlib is available" do
-    before(:each) do
-      Puppet.features.stubs(:zlib?).returns true
-
-      require 'puppet/network/http/compression'
-      class HttpUncompressor
-        include Puppet::Network::HTTP::Compression::Active
-      end
-
-      @uncompressor = HttpUncompressor.new
+    require 'puppet/network/http/compression'
+    class ActiveUncompressor
+      include Puppet::Network::HTTP::Compression::Active
     end
 
+    let(:uncompressor) { ActiveUncompressor.new }
+
     it "should have a module function that returns the Active underlying module" do
       expect(Puppet::Network::HTTP::Compression.module).to eq(Puppet::Network::HTTP::Compression::Active)
     end
 
     it "should add an Accept-Encoding header supporting compression" do
-      headers = @uncompressor.add_accept_encoding({})
+      headers = uncompressor.add_accept_encoding({})
       expect(headers).to have_key('accept-encoding')
       expect(headers['accept-encoding']).to match(/gzip/)
       expect(headers['accept-encoding']).to match(/deflate/)
@@ -61,129 +71,167 @@ describe "http compression" do
     end
 
     describe "when uncompressing response body" do
-      before do
-        @response = stub 'response'
-        @response.stubs(:[]).with('content-encoding')
-        @response.stubs(:body).returns("mydata")
-      end
+      context "without compression" do
+        it "should return untransformed response body with no content-encoding" do
+          stubs_response_with(response, nil, data)
 
-      it "should return untransformed response body with no content-encoding" do
-        expect(@uncompressor.uncompress_body(@response)).to eq("mydata")
-      end
+          expect(uncompressor.uncompress_body(response)).to eq(data)
+        end
+
+        it "should return untransformed response body with 'identity' content-encoding" do
+          stubs_response_with(response, 'identity', data)
 
-      it "should return untransformed response body with 'identity' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns('identity')
-        expect(@uncompressor.uncompress_body(@response)).to eq("mydata")
+          expect(uncompressor.uncompress_body(response)).to eq(data)
+        end
       end
 
-      it "should use a Zlib inflater with 'deflate' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns('deflate')
+      context "with 'zlib' content-encoding" do
+        it "should use a Zlib inflater" do
+          stubs_response_with(response, 'deflate', compressed_zlib)
 
-        inflater = stub 'inflater'
-        Zlib::Inflate.expects(:new).returns(inflater)
-        inflater.expects(:inflate).with("mydata").returns "uncompresseddata"
+          expect(uncompressor.uncompress_body(response)).to eq(data)
+        end
 
-        expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
       end
 
-      it "should use a GzipReader with 'gzip' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns('gzip')
+      context "with 'gzip' content-encoding" do
+        it "should use a GzipReader" do
+          stubs_response_with(response, 'gzip', compressed_gzip)
+
+          expect(uncompressor.uncompress_body(response)).to eq(data)
+        end
+
+        it "should correctly decompress PSON containing UTF-8 in Binary Encoding" do
+          # Simulate a compressed response body containing PSON containing UTF-8
+          # using different UTF-8 widths:
+
+          # \u06ff - ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+          # \u16A0 - ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+          # \u{2070E} - 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
 
-        io = stub 'io'
-        StringIO.expects(:new).with("mydata").returns io
+          pson = "foo\u06ff\u16A0\u{2070E}".to_pson # unicode expression eqivalent of "foo\xDB\xBF\xE1\x9A\xA0\xF0\xA0\x9C\x8E\" per above
+          writer = Zlib::GzipWriter.new(StringIO.new)
+          writer.write(pson)
+          compressed_body = writer.close.string
 
-        reader = stub 'gzip reader'
-        Zlib::GzipReader.expects(:new).with(io).returns(reader)
-        reader.expects(:read).returns "uncompresseddata"
+          begin
+            default_external = Encoding.default_external
+            Encoding.default_external = Encoding::ISO_8859_1
 
-        expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
+            stubs_response_with(response, 'gzip', compressed_body)
+
+            uncompressed = uncompressor.uncompress_body(response)
+            # By default Zlib::GzipReader decompresses into Encoding.default_external, and we want to ensure our result is BINARY too
+            expect(uncompressed.encoding).to eq(Encoding::BINARY)
+            expect(uncompressed).to eq("\"foo\xDB\xBF\xE1\x9A\xA0\xF0\xA0\x9C\x8E\"".force_encoding(Encoding::BINARY))
+          ensure
+            Encoding.default_external = default_external
+          end
+        end
       end
     end
 
     describe "when uncompressing by chunk" do
-      before do
-        @response = stub 'response'
-        @response.stubs(:[]).with('content-encoding')
+      it "should yield an identity uncompressor with no content-encoding" do
+        stubs_response_with(response, nil, data)
 
-        @inflater = stub_everything 'inflater'
-        Zlib::Inflate.stubs(:new).returns(@inflater)
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::IdentityAdapter, &b)
+        }
       end
 
-      it "should yield an identity uncompressor with no content-encoding" do
-        @uncompressor.uncompress(@response) { |u|
-          expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
+      it "should yield an identity uncompressor with 'identity' content-encoding" do
+        stubs_response_with(response, 'identity', data)
+
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::IdentityAdapter, &b)
         }
       end
 
-      it "should yield an identity uncompressor with 'identity' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns 'identity'
-        @uncompressor.uncompress(@response) { |u|
-          expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
+      it "should yield a Zlib uncompressor with 'gzip' content-encoding" do
+        stubs_response_with(response, 'gzip', compressed_gzip)
+
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::ZlibAdapter, &b)
         }
       end
 
-      %w{gzip deflate}.each do |c|
-        it "should yield a Zlib uncompressor with '#{c}' content-encoding" do
-          @response.stubs(:[]).with('content-encoding').returns c
-          @uncompressor.uncompress(@response) { |u|
-            expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::Active::ZlibAdapter)
-          }
-        end
+      it "should yield a Zlib uncompressor with 'deflate' content-encoding" do
+        stubs_response_with(response, 'deflate', compressed_zlib)
+
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::ZlibAdapter, &b)
+        }
       end
 
       it "should close the underlying adapter" do
+        stubs_response_with(response, 'identity', data)
         adapter = stub_everything 'adapter'
         Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
 
         adapter.expects(:close)
-        @uncompressor.uncompress(@response) { |u| }
+        uncompressor.uncompress(response) { |u| }
       end
-    end
 
-    describe "zlib adapter" do
-      before do
-        @inflater = stub_everything 'inflater'
-        Zlib::Inflate.stubs(:new).returns(@inflater)
-        @adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
+      it "should close the underlying adapter if the yielded block raises" do
+        stubs_response_with(response, 'identity', data)
+        adapter = stub_everything 'adapter'
+        Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
+
+        adapter.expects(:close)
+        expect {
+          uncompressor.uncompress(response) { |u| raise ArgumentError, "whoops" }
+        }.to raise_error(ArgumentError, "whoops")
       end
+    end
 
+    describe "zlib adapter" do
       it "should initialize the underlying inflater with gzip/zlib header parsing" do
         Zlib::Inflate.expects(:new).with(15+32)
+
         Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
       end
 
-      it "should inflate the given chunk" do
-        @inflater.expects(:inflate).with("chunk")
-        @adapter.uncompress("chunk")
-      end
+      it "should return the given chunk" do
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
 
-      it "should return the inflated chunk" do
-        @inflater.stubs(:inflate).with("chunk").returns("uncompressed")
-        expect(@adapter.uncompress("chunk")).to eq("uncompressed")
+        expect(adapter.uncompress(compressed_zlib)).to eq(data)
       end
 
       it "should try a 'regular' inflater on Zlib::DataError" do
-        @inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
-        inflater = stub_everything 'inflater2'
-        inflater.expects(:inflate).with("chunk").returns("uncompressed")
-        Zlib::Inflate.expects(:new).with.returns(inflater)
-        @adapter.uncompress("chunk")
+        inflater = Zlib::Inflate.new(15 + 32)
+        inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+
+        expect(adapter.uncompress(compressed_zlib)).to eq(data)
       end
 
       it "should raise the error the second time" do
-        @inflater.stubs(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
-        Zlib::Inflate.expects(:new).with.returns(@inflater)
-        expect { @adapter.uncompress("chunk") }.to raise_error
+        inflater = Zlib::Inflate.new(15 + 32)
+        inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+
+        expect { adapter.uncompress("this is not compressed data") }.to raise_error(Zlib::DataError, /incorrect header check/)
       end
 
-      it "should finish the stream on close" do
-        @inflater.expects(:finish)
-        @adapter.close
+      it "should finish and close the stream" do
+        inflater = stub 'inflater'
+        inflater.expects(:finish)
+        inflater.expects(:close)
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+
+        adapter.close
       end
 
-      it "should close the stream on close" do
-        @inflater.expects(:close)
-        @adapter.close
+      it "should close the stream even if finish raises" do
+        inflater = stub 'inflater'
+        inflater.expects(:finish).raises(Zlib::BufError)
+        inflater.expects(:close)
+
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+        expect {
+          adapter.close
+        }.to raise_error(Zlib::BufError)
       end
     end
   end

data/spec/unit/network/http/connection_spec.rb

@@ -42,31 +42,18 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
-  context "when methods that accept a block are called with a block" do
-    let (:host) { "my_server" }
+  context "when handling requests", :vcr do
+    let (:host) { "my-server" }
     let (:port) { 8140 }
     let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
 
-    before :each do
-      httpok.stubs(:body).returns ""
-
-      # This stubbing relies a bit more on knowledge of the internals of Net::HTTP
-      # than I would prefer, but it works on ruby 1.8.7 and 1.9.3, and it seems
-      # valuable enough to have tests for blocks that this is probably warranted.
-      socket = stub_everything("socket")
-      TCPSocket.stubs(:open).returns(socket)
-
-      Net::HTTP::Post.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Head.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Get.any_instance.stubs(:exec).returns("")
-      Net::HTTPResponse.stubs(:read_new).returns(httpok)
-    end
-
-    [:request_get, :request_head, :request_post].each do |method|
+    { :request_get  => {},
+      :request_head => {},
+      :request_post => "param: value" }.each do |method,body|
       context "##{method}" do
         it "should yield to the block" do
           block_executed = false
-          subject.send(method, "/foo", {}) do |response|
+          subject.send(method, "/foo", body) do |response|
             block_executed = true
           end
           expect(block_executed).to eq(true)
@@ -118,6 +105,14 @@ describe Puppet::Network::HTTP::Connection do
     let (:host) { "my_server" }
     let (:port) { 8140 }
 
+    before :all do
+      WebMock.disable!
+    end
+
+    after :all do
+      WebMock.enable!
+    end
+
     it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet.features.microsoft_windows? do
       connection = Puppet::Network::HTTP::Connection.new(
         host, port,
@@ -168,6 +163,7 @@ describe Puppet::Network::HTTP::Connection do
 
       Net::HTTP.any_instance.stubs(:start)
       Net::HTTP.any_instance.stubs(:request).returns(httpok)
+      Puppet::Network::HTTP::Pool.any_instance.stubs(:setsockopts)
 
       connection.get('request')
     end
@@ -300,4 +296,14 @@ describe Puppet::Network::HTTP::Connection do
       expect(request['authorization']).to match(/^Basic/)
     end.returns(httpok)
   end
+
+  it "sets HTTP User-Agent header" do
+    puppet_ua = "Puppet/#{Puppet.version} Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
+
+    Net::HTTP.any_instance.expects(:request).with do |request|
+      expect(request['User-Agent']).to eq(puppet_ua)
+    end.returns(httpok)
+
+    subject.get('/path')
+  end
 end

data/spec/unit/network/http/error_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Network::HTTP::Error do
   end
 
   describe Puppet::Network::HTTP::Error::HTTPServerError do
-    it "should serialize to JSON that matches the error schema and has the optional stacktrace property" do
+    it "should serialize to JSON that matches the error schema" do
       begin
         raise Exception, "a wild Exception appeared!"
       rescue Exception => e

data/spec/unit/network/http/factory_spec.rb

@@ -1,8 +1,13 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
+require 'puppet/util/http_proxy'
 
 describe Puppet::Network::HTTP::Factory do
+  before(:all) do
+    ENV['http_proxy'] = nil
+    ENV['HTTP_PROXY'] = nil
+  end
   before :each do
     Puppet::SSL::Key.indirection.terminus_class = :memory
     Puppet::SSL::CertificateRequest.indirection.terminus_class = :memory
@@ -41,13 +46,25 @@ describe Puppet::Network::HTTP::Factory do
 
     it "should not set a proxy if the value is 'none'" do
       Puppet[:http_proxy_host] = 'none'
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
+      conn = create_connection(site)
+
+      expect(conn.proxy_address).to be_nil
+    end
+
+    it 'should not set a proxy if a no_proxy env var matches the destination' do
+      Puppet[:http_proxy_host] = proxy_host
+      Puppet[:http_proxy_port] = proxy_port
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns true
       conn = create_connection(site)
 
       expect(conn.proxy_address).to be_nil
+      expect(conn.proxy_port).to be_nil
     end
 
     it 'sets proxy_address' do
       Puppet[:http_proxy_host] = proxy_host
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
       conn = create_connection(site)
 
       expect(conn.proxy_address).to eq(proxy_host)
@@ -56,6 +73,7 @@ describe Puppet::Network::HTTP::Factory do
     it 'sets proxy address and port' do
       Puppet[:http_proxy_host] = proxy_host
       Puppet[:http_proxy_port] = proxy_port
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
       conn = create_connection(site)
 
       expect(conn.proxy_port).to eq(proxy_port)

data/spec/unit/network/http/handler_spec.rb

@@ -18,8 +18,8 @@ describe Puppet::Network::HTTP::Handler do
 
   def a_request(method = "HEAD", path = "/production/#{indirection.name}/unknown")
     {
-      :accept_header => "pson",
-      :content_type_header => "text/pson",
+      :accept_header => "application/json",
+      :content_type_header => "application/json",
       :method => method,
       :path => path,
       :params => {},
@@ -68,15 +68,22 @@ describe Puppet::Network::HTTP::Handler do
 
       res_body = JSON(res[:body])
 
-      expect(res[:content_type_header]).to eq("application/json")
+      expect(res[:content_type_header]).to eq("application/json; charset=utf-8")
       expect(res_body["issue_kind"]).to eq("HANDLER_NOT_FOUND")
       expect(res_body["message"]).to eq("Not Found: No route for GET /vtest/foo")
       expect(res[:status]).to eq(404)
     end
 
-    it "returns a structured error response with a stacktrace when the server encounters an internal error" do
+    it "returns a structured error response when the server encounters an internal error" do
+      error = StandardError.new("the sky is falling!")
+      original_stacktrace = ['a.rb', 'b.rb']
+      error.set_backtrace(original_stacktrace)
+
       handler = PuppetSpec::Handler.new(
-        Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise StandardError.new("the sky is falling!")}))
+        Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise error}))
+
+      # Stacktraces should be included in logs
+      Puppet.expects(:err).with("Server Error: the sky is falling!\na.rb\nb.rb")
 
       req = a_request("GET", "/vtest/foo")
       res = {}
@@ -85,11 +92,9 @@ describe Puppet::Network::HTTP::Handler do
 
       res_body = JSON(res[:body])
 
-      expect(res[:content_type_header]).to eq("application/json")
+      expect(res[:content_type_header]).to eq("application/json; charset=utf-8")
       expect(res_body["issue_kind"]).to eq(Puppet::Network::HTTP::Issues::RUNTIME_ERROR.to_s)
       expect(res_body["message"]).to eq("Server Error: the sky is falling!")
-      expect(res_body["stacktrace"].is_a?(Array) && !res_body["stacktrace"].empty?).to be_truthy
-      expect(res_body["stacktrace"][0]).to match("spec/unit/network/http/handler_spec.rb")
       expect(res[:status]).to eq(500)
     end
 
@@ -131,24 +136,19 @@ describe Puppet::Network::HTTP::Handler do
       handler.process(request, response)
     end
 
-    it "should raise an error if the request is formatted in an unknown format" do
-      handler.stubs(:content_type_header).returns "unknown format"
-      expect { handler.request_format(request) }.to raise_error
-    end
-
     it "should still find the correct format if content type contains charset information" do
       request = Puppet::Network::HTTP::Request.new({ 'content-type' => "text/plain; charset=UTF-8" },
                                                    {}, 'GET', '/', nil)
-      expect(request.format).to eq("s")
+      expect(request.formatter.name).to eq(:s)
     end
 
     # PUP-3272
     # This used to be for YAML, and doing a to_yaml on an array.
-    # The result with to_pson is something different, the result is a string
+    # The result with to_json is something different, the result is a string
     # Which seems correct. Looks like this was some kind of nesting option "yaml inside yaml" ?
     # Removing the test
-#    it "should deserialize PSON parameters" do
-#      params = {'my_param' => [1,2,3].to_pson}
+#    it "should deserialize JSON parameters" do
+#      params = {'my_param' => [1,2,3].to_json}
 #
 #      decoded_params = handler.send(:decode_params, params)
 #
@@ -156,7 +156,6 @@ describe Puppet::Network::HTTP::Handler do
 #    end
   end
 
-
   describe "when resolving node" do
     it "should use a look-up from the ip address" do
       Resolv.expects(:getname).with("1.2.3.4").returns("host.domain.com")

data/spec/unit/network/http/pool_spec.rb

@@ -109,6 +109,31 @@ describe Puppet::Network::HTTP::Pool do
       end rescue nil
     end
 
+    it 'sets keepalive bit on network socket' do
+      pool = create_pool
+      s = Socket.new(Socket::PF_INET, Socket::SOCK_STREAM)
+      pool.setsockopts(Net::BufferedIO.new(s))
+
+      # On windows, Socket.getsockopt() doesn't return exactly the same data
+      # as an equivalent Socket::Option.new() statement, so we strip off the
+      # unrelevant bits only on this platform.
+      #
+      # To make sure we're not voiding the test case by doing this, we check
+      # both with and without the keepalive bit set.
+      #
+      # This workaround can be removed once all the ruby versions we care about
+      # have the patch from https://bugs.ruby-lang.org/issues/11958 applied.
+      #
+      if Puppet::Util::Platform.windows?
+        keepalive   = Socket::Option.bool(:INET, :SOCKET, :KEEPALIVE, true).data[0]
+        nokeepalive = Socket::Option.bool(:INET, :SOCKET, :KEEPALIVE, false).data[0]
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).data).to eq(keepalive)
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).data).to_not eq(nokeepalive)
+      else
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).bool).to eq(true)
+      end
+    end
+
     context 'when releasing connections' do
       it 'releases HTTP connections' do
         conn = create_connection(site)
@@ -150,6 +175,7 @@ describe Puppet::Network::HTTP::Pool do
       conn = create_connection(site)
       pool = create_pool
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -169,6 +195,7 @@ describe Puppet::Network::HTTP::Pool do
 
       conn = create_connection(site)
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -179,6 +206,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -205,6 +233,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool_with_expired_connections(site, conn)
       pool.factory.expects(:create_connection => stub('conn', :start => nil))
+      pool.expects(:setsockopts)
 
       pool.borrow(site, verify)
     end
@@ -217,6 +246,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool_with_expired_connections(site, conn)
       pool.factory.expects(:create_connection => stub('open_conn', :start => nil))
+      pool.expects(:setsockopts)
 
       pool.borrow(site, verify)
     end