puppet 5.5.22-x86-mingw32 → 6.0.0-x86-mingw32

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

@@ -1,24 +1,26 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "http compression" do
   let(:data)            { "uncompresseddata" }
-  let(:response)        { double('response') }
+  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
+    writer.close
+    str.string
   end
 
   def stubs_response_with(response, content_encoding, body)
-    allow(response).to receive(:[]).with('content-encoding').and_return(content_encoding)
-    allow(response).to receive(:body).and_return(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
-      allow(Puppet.features).to receive(:zlib?).and_return(false)
+      Puppet.features.stubs(:zlib?).returns false
 
       require 'puppet/network/http/compression'
       class HttpUncompressor
@@ -37,12 +39,12 @@ describe "http compression" do
     end
 
     it "should not tamper the body" do
-      response = double('response', :body => data)
+      response = stub 'response', :body => data
       expect(@uncompressor.uncompress_body(response)).to eq(data)
     end
 
     it "should yield an identity uncompressor" do
-      response = double('response')
+      response = stub 'response'
       @uncompressor.uncompress(response) { |u|
         expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
       }
@@ -109,9 +111,11 @@ describe "http compression" do
           # \u{2070E} - 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
 
           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)
+          compressed_body_io = StringIO.new
+          writer = Zlib::GzipWriter.new(compressed_body_io)
           writer.write(pson)
-          compressed_body = writer.close.string
+          writer.close
+          compressed_body = compressed_body_io.string
 
           begin
             default_external = Encoding.default_external
@@ -165,19 +169,19 @@ describe "http compression" do
 
       it "should close the underlying adapter" do
         stubs_response_with(response, 'identity', data)
-        adapter = double('adapter')
-        expect(Puppet::Network::HTTP::Compression::IdentityAdapter).to receive(:new).and_return(adapter)
+        adapter = stub_everything 'adapter'
+        Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
 
-        expect(adapter).to receive(:close)
+        adapter.expects(:close)
         uncompressor.uncompress(response) { |u| }
       end
 
       it "should close the underlying adapter if the yielded block raises" do
         stubs_response_with(response, 'identity', data)
-        adapter = double('adapter')
-        expect(Puppet::Network::HTTP::Compression::IdentityAdapter).to receive(:new).and_return(adapter)
+        adapter = stub_everything 'adapter'
+        Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
 
-        expect(adapter).to receive(:close)
+        adapter.expects(:close)
         expect {
           uncompressor.uncompress(response) { |u| raise ArgumentError, "whoops" }
         }.to raise_error(ArgumentError, "whoops")
@@ -186,7 +190,7 @@ describe "http compression" do
 
     describe "zlib adapter" do
       it "should initialize the underlying inflater with gzip/zlib header parsing" do
-        expect(Zlib::Inflate).to receive(:new).with(15 + 32)
+        Zlib::Inflate.expects(:new).with(15+32)
 
         Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
       end
@@ -199,7 +203,7 @@ describe "http compression" do
 
       it "should try a 'regular' inflater on Zlib::DataError" do
         inflater = Zlib::Inflate.new(15 + 32)
-        expect(inflater).to receive(:inflate).and_raise(Zlib::DataError.new("not a zlib stream"))
+        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)
@@ -207,25 +211,25 @@ describe "http compression" do
 
       it "should raise the error the second time" do
         inflater = Zlib::Inflate.new(15 + 32)
-        expect(inflater).to receive(:inflate).and_raise(Zlib::DataError.new("not a zlib stream"))
+        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 and close the stream" do
-        inflater = double('inflater')
-        expect(inflater).to receive(:finish)
-        expect(inflater).to receive(:close)
+        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 even if finish raises" do
-        inflater = double('inflater')
-        expect(inflater).to receive(:finish).and_raise(Zlib::BufError)
-        expect(inflater).to receive(:close)
+        inflater = stub 'inflater'
+        inflater.expects(:finish).raises(Zlib::BufError)
+        inflater.expects(:close)
 
         adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
         expect {

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

@@ -1,5 +1,8 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http/connection'
+require 'puppet_spec/validators'
+require 'puppet/test_ca'
 
 describe Puppet::Network::HTTP::Connection do
 
@@ -61,6 +64,94 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
+  shared_examples_for 'ssl verifier' do
+    include PuppetSpec::Files
+
+    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::Util::Platform.windows? do
+      connection = Puppet::Network::HTTP::Connection.new(
+        host, port,
+        :verify => ConstantErrorValidator.new(:fails_with => 'certificate verify failed',
+                                              :error_string => 'shady looking signature'))
+
+      expect do
+        connection.get('request')
+      end.to raise_error(Puppet::Error, "certificate verify failed: [shady looking signature]")
+    end
+
+    it "should provide a helpful error message when hostname was not match with server certificate", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
+      Puppet[:confdir] = tmpdir('conf')
+
+      connection = Puppet::Network::HTTP::Connection.new(
+      host, port,
+      :verify => ConstantErrorValidator.new(
+        :fails_with => 'hostname was not match with server certificate',
+        :peer_certs => [Puppet::TestCa.new.generate('not_my_server',
+                                                    :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:not_my_server').content]))
+
+      expect do
+        connection.get('request')
+      end.to raise_error(Puppet::Error) do |error|
+        error.message =~ /\AServer hostname 'my_server' did not match server certificate; expected one of (.+)/
+        expect($1.split(', ')).to match_array(%w[DNS:foo DNS:bar DNS:baz DNS:not_my_server not_my_server])
+      end
+    end
+
+    it "should pass along the error message otherwise" do
+      connection = Puppet::Network::HTTP::Connection.new(
+        host, port,
+        :verify => ConstantErrorValidator.new(:fails_with => 'some other message'))
+
+      expect do
+        connection.get('request')
+      end.to raise_error(/some other message/)
+    end
+
+    it "should check all peer certificates for upcoming expiration", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
+      Puppet[:confdir] = tmpdir('conf')
+      cert = Puppet::TestCa.new.generate('server',
+                                         :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:server')
+
+      connection = Puppet::Network::HTTP::Connection.new(
+        host, port,
+        :verify => NoProblemsValidator.new(cert))
+
+      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
+  end
+
+  context "when using single use HTTPS connections", :unless => RUBY_PLATFORM == 'java' do
+    it_behaves_like 'ssl verifier' do
+    end
+  end
+
+  context "when using persistent HTTPS connections", :unless => RUBY_PLATFORM == 'java' do
+    around :each do |example|
+      pool = Puppet::Network::HTTP::Pool.new
+      Puppet.override(:http_pool => pool) do
+        example.run
+      end
+      pool.close
+    end
+
+    it_behaves_like 'ssl verifier' do
+    end
+  end
+
   context "when response is a redirect" do
     let (:site)       { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
     let (:other_site) { Puppet::Network::HTTP::Site.new('http', 'redirected', 9292) }
@@ -70,7 +161,7 @@ describe Puppet::Network::HTTP::Connection do
     let (:httpredirection) do
       response = Net::HTTPFound.new('1.1', 302, 'Moved Temporarily')
       response['location'] = "#{other_site.addr}/#{other_path}"
-      allow(response).to receive(:read_body).and_return("This resource has moved")
+      response.stubs(:read_body).returns("This resource has moved")
       response
     end
 
@@ -80,23 +171,24 @@ describe Puppet::Network::HTTP::Connection do
     end
 
     it "should redirect to the final resource location" do
-      http = double('http')
-      allow(http).to receive(:request).and_return(httpredirection, httpok)
+      http = stub('http')
+      http.stubs(:request).returns(httpredirection).then.returns(httpok)
 
+      seq = sequence('redirection')
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http).ordered
-      expect(pool).to receive(:with_connection).with(other_site, anything).and_yield(http).ordered
+      pool.expects(:with_connection).with(site, anything).yields(http).in_sequence(seq)
+      pool.expects(:with_connection).with(other_site, anything).yields(http).in_sequence(seq)
 
       conn = create_connection(site, :verify => verify)
       conn.get('/foo')
     end
 
     def expects_redirection(conn, &block)
-      http = double('http')
-      allow(http).to receive(:request).and_return(httpredirection)
+      http = stub('http')
+      http.stubs(:request).returns(httpredirection)
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
+      pool.expects(:with_connection).with(site, anything).yields(http)
       pool
     end
 
@@ -110,7 +202,7 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 0)
 
       pool = expects_redirection(conn)
-      expect(pool).not_to receive(:with_connection).with(other_site, anything)
+      pool.expects(:with_connection).with(other_site, anything).never
 
       expects_limit_exceeded(conn)
     end
@@ -119,7 +211,7 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 1)
 
       pool = expects_redirection(conn)
-      expect(pool).to receive(:with_connection).with(other_site, anything).once
+      pool.expects(:with_connection).with(other_site, anything).once
 
       expects_limit_exceeded(conn)
     end
@@ -128,14 +220,14 @@ describe Puppet::Network::HTTP::Connection do
       conn = create_connection(site, :verify => verify, :redirect_limit => 3)
 
       pool = expects_redirection(conn)
-      expect(pool).to receive(:with_connection).with(other_site, anything).exactly(3).times
+      pool.expects(:with_connection).with(other_site, anything).times(3)
 
       expects_limit_exceeded(conn)
     end
   end
 
   context "when response indicates an overloaded server" do
-    let(:http) { double('http', :started? => true) }
+    let(:http) { stub('http') }
     let(:site) { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
     let(:verify) { Puppet::SSL::Validator.no_validator }
     let(:httpunavailable) { Net::HTTPServiceUnavailable.new('1.1', 503, 'Service Unavailable') }
@@ -154,11 +246,10 @@ describe Puppet::Network::HTTP::Connection do
     end
 
     it "should return a 503 response if Retry-After is not set" do
-      allow(http).to receive(:request).and_return(httpunavailable)
+      http.stubs(:request).returns(httpunavailable)
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
-      allow(http).to receive(:finish)
+      pool.expects(:with_connection).with(site, anything).yields(http)
 
       result = subject.get('/foo')
 
@@ -167,37 +258,24 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should return a 503 response if Retry-After is not convertible to an Integer or RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'foo'
-      allow(http).to receive(:request).and_return(httpunavailable)
-      allow(http).to receive(:finish)
+      http.stubs(:request).returns(httpunavailable)
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
+      pool.expects(:with_connection).with(site, anything).yields(http)
 
       result = subject.get('/foo')
 
       expect(result.code).to eq(503)
     end
 
-    it "should close the connection before sleeping" do
-      allow(http).to receive(:request).and_return(httpunavailable, httpok)
-
-      pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
-
-      expect(http).to receive(:finish)
-
-      subject.get('/foo')
-    end
-
     it "should sleep and retry if Retry-After is an Integer" do
       httpunavailable['Retry-After'] = '42'
-      allow(http).to receive(:request).and_return(httpunavailable, httpok)
-      allow(http).to receive(:finish)
+      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
+      pool.expects(:with_connection).with(site, anything).twice.yields(http)
 
-      expect(::Kernel).to receive(:sleep).with(42)
+      ::Kernel.expects(:sleep).with(42)
 
       result = subject.get('/foo')
 
@@ -206,16 +284,15 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should sleep and retry if Retry-After is an RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'Wed, 13 Apr 2005 15:18:05 GMT'
-      allow(http).to receive(:request).and_return(httpunavailable, httpok)
-      allow(http).to receive(:finish)
+      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
 
       now = DateTime.new(2005, 4, 13, 8, 17, 5, '-07:00')
-      allow(DateTime).to receive(:now).and_return(now)
+      DateTime.stubs(:now).returns(now)
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
+      pool.expects(:with_connection).with(site, anything).twice.yields(http)
 
-      expect(::Kernel).to receive(:sleep).with(60)
+      ::Kernel.expects(:sleep).with(60)
 
       result = subject.get('/foo')
 
@@ -224,14 +301,13 @@ describe Puppet::Network::HTTP::Connection do
 
     it "should sleep for no more than the Puppet runinterval" do
       httpunavailable['Retry-After'] = '60'
-      allow(http).to receive(:request).and_return(httpunavailable, httpok)
-      allow(http).to receive(:finish)
+      http.stubs(:request).returns(httpunavailable).then.returns(httpok)
       Puppet[:runinterval] = 30
 
       pool = Puppet.lookup(:http_pool)
-      expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
+      pool.expects(:with_connection).with(site, anything).twice.yields(http)
 
-      expect(::Kernel).to receive(:sleep).with(30)
+      ::Kernel.expects(:sleep).with(30)
 
       subject.get('/foo')
     end
@@ -268,44 +344,18 @@ describe Puppet::Network::HTTP::Connection do
   end
 
   def expect_request_with_basic_auth
-    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
+    Net::HTTP.any_instance.expects(:request).with do |request|
       expect(request['authorization']).to match(/^Basic/)
-    end.and_return(httpok)
+    end.returns(httpok)
   end
 
   it "sets HTTP User-Agent header" do
     puppet_ua = "Puppet/#{Puppet.version} Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
 
-    expect_any_instance_of(Net::HTTP).to receive(:request) do |_, request|
+    Net::HTTP.any_instance.expects(:request).with do |request|
       expect(request['User-Agent']).to eq(puppet_ua)
-    end.and_return(httpok)
+    end.returns(httpok)
 
     subject.get('/path')
   end
-
-  describe 'connection request errors' do
-    it "logs and raises generic http errors" do
-      generic_error = Net::HTTPError.new('generic error', double("response"))
-      expect_any_instance_of(Net::HTTP).to receive(:request).and_raise(generic_error)
-
-      expect(Puppet).to receive(:log_exception).with(anything, /^.*failed: generic error$/)
-      expect { subject.get('/foo') }.to raise_error(generic_error)
-    end
-
-    it "logs and raises timeout errors" do
-      timeout_error = Timeout::Error.new
-      expect_any_instance_of(Net::HTTP).to receive(:request).and_raise(timeout_error)
-
-      expect(Puppet).to receive(:log_exception).with(anything, /^.*timed out after .* seconds$/)
-      expect { subject.get('/foo') }.to raise_error(timeout_error)
-    end
-
-    it "logs and raises eof errors" do
-      eof_error = EOFError
-      expect_any_instance_of(Net::HTTP).to receive(:request).and_raise(eof_error)
-
-      expect(Puppet).to receive(:log_exception).with(anything, /^.*interrupted after .* seconds$/)
-      expect { subject.get('/foo') }.to raise_error(eof_error)
-    end
-  end
 end