puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
 require 'puppet/util/http_proxy'
@@ -36,17 +37,16 @@ describe Puppet::Network::HTTP::Factory do
   it 'creates a connection supporting at least HTTP 1.1' do
     conn = create_connection(site)
 
-    expect(conn.class.version_1_1? || conn.class.version_1_2?).to be_truthy
+    expect(any_of(conn.class.version_1_1?, conn.class.version_1_1?)).to be_truthy
   end
 
   context "proxy settings" do
     let(:proxy_host) { 'myhost' }
     let(:proxy_port) { 432 }
-    let(:proxy_user) { 'mo' }
-    let(:proxy_pass) { 'password' }
 
-    it "should not set a proxy if the http_proxy_host setting is 'none'" 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
@@ -55,18 +55,7 @@ describe Puppet::Network::HTTP::Factory do
     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.withenv('NO_PROXY' => site.host) do
-        conn = create_connection(site)
-
-        expect(conn.proxy_address).to be_nil
-        expect(conn.proxy_port).to be_nil
-      end
-    end
-
-    it 'should not set a proxy if the no_proxy setting matches the destination' do
-      Puppet[:http_proxy_host] = proxy_host
-      Puppet[:http_proxy_port] = proxy_port
-      Puppet[:no_proxy] = site.host
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns true
       conn = create_connection(site)
 
       expect(conn.proxy_address).to be_nil
@@ -75,6 +64,7 @@ describe Puppet::Network::HTTP::Factory do
 
     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)
@@ -83,22 +73,11 @@ 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)
     end
-
-    it 'sets proxy user and password' do
-      Puppet[:http_proxy_host] = proxy_host
-      Puppet[:http_proxy_port] = proxy_port
-      Puppet[:http_proxy_user] = proxy_user
-      Puppet[:http_proxy_password] = proxy_pass
-
-      conn = create_connection(site)
-
-      expect(conn.proxy_user).to eq(proxy_user)
-      expect(conn.proxy_pass).to eq(proxy_pass)
-    end
   end
 
   context 'socket timeouts' do
@@ -117,8 +96,7 @@ describe Puppet::Network::HTTP::Factory do
     end
   end
 
-  it "disables ruby's http_keepalive_timeout on Ruby 2" do
-    skip "Requires Ruby >= 2.0" unless RUBY_VERSION.to_i >= 2
+  it "disables ruby's http_keepalive_timeout" do
     conn = create_connection(site)
 
     expect(conn.keep_alive_timeout).to eq(2147483647)
@@ -126,7 +104,6 @@ describe Puppet::Network::HTTP::Factory do
 
   context 'source address' do
     it 'defaults to system-defined' do
-      skip "Requires Ruby >= 2.0" unless RUBY_VERSION.to_i >= 2
       conn = create_connection(site)
 
       expect(conn.local_host).to be(nil)
@@ -134,15 +111,9 @@ describe Puppet::Network::HTTP::Factory do
 
     it 'sets the local_host address' do
       Puppet[:sourceaddress] = "127.0.0.1"
-      if RUBY_VERSION.to_i >= 2
-        conn = create_connection(site)
-
-        expect(conn.local_host).to eq('127.0.0.1')
-      else
-        expect {
-          create_connection(site)
-        }.to raise_error(ArgumentError, "Setting 'sourceaddress' is unsupported by this version of Net::HTTP.")
-      end
+      conn = create_connection(site)
+
+      expect(conn.local_host).to eq('127.0.0.1')
     end
   end
 end

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

@@ -1,8 +1,12 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/handler'
+
 require 'puppet/indirector_testing'
+
 require 'puppet/network/authorization'
+
 require 'puppet/network/http'
 
 describe Puppet::Network::HTTP::Handler do
@@ -80,7 +84,7 @@ describe Puppet::Network::HTTP::Handler do
         Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise error}))
 
       # Stacktraces should be included in logs
-      expect(Puppet).to receive(:err).with("Server Error: the sky is falling!\na.rb\nb.rb")
+      Puppet.expects(:err).with("Server Error: the sky is falling!\na.rb\nb.rb")
 
       req = a_request("GET", "/vtest/foo")
       res = {}
@@ -103,8 +107,8 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     before do
-      allow(handler).to receive(:check_authorization)
-      allow(handler).to receive(:warn_if_near_expiration)
+      handler.stubs(:check_authorization)
+      handler.stubs(:warn_if_near_expiration)
     end
 
     it "should setup a profiler when the puppet-profiling header exists" do
@@ -113,8 +117,13 @@ describe Puppet::Network::HTTP::Handler do
 
       p = PuppetSpec::HandlerProfiler.new
 
-      expect(Puppet::Util::Profiler).to receive(:add_profiler).with(be_a(Puppet::Util::Profiler::WallClock)).and_return(p)
-      expect(Puppet::Util::Profiler).to receive(:remove_profiler).with(p)
+      Puppet::Util::Profiler.expects(:add_profiler).with { |profiler|
+        profiler.is_a? Puppet::Util::Profiler::WallClock
+      }.returns(p)
+
+      Puppet::Util::Profiler.expects(:remove_profiler).with { |profiler|
+        profiler == p
+      }
 
       handler.process(request, response)
     end
@@ -123,7 +132,7 @@ describe Puppet::Network::HTTP::Handler do
       request = a_request
       request[:params] = { }
 
-      expect(Puppet::Util::Profiler).not_to receive(:add_profiler)
+      Puppet::Util::Profiler.expects(:add_profiler).never
 
       handler.process(request, response)
     end
@@ -150,19 +159,19 @@ describe Puppet::Network::HTTP::Handler do
 
   describe "when resolving node" do
     it "should use a look-up from the ip address" do
-      expect(Resolv).to receive(:getname).with("1.2.3.4").and_return("host.domain.com")
+      Resolv.expects(:getname).with("1.2.3.4").returns("host.domain.com")
 
       handler.resolve_node(:ip => "1.2.3.4")
     end
 
     it "should return the look-up result" do
-      allow(Resolv).to receive(:getname).with("1.2.3.4").and_return("host.domain.com")
+      Resolv.stubs(:getname).with("1.2.3.4").returns("host.domain.com")
 
       expect(handler.resolve_node(:ip => "1.2.3.4")).to eq("host.domain.com")
     end
 
     it "should return the ip address if resolving fails" do
-      allow(Resolv).to receive(:getname).with("1.2.3.4").and_raise(RuntimeError, "no such host")
+      Resolv.stubs(:getname).with("1.2.3.4").raises(RuntimeError, "no such host")
 
       expect(handler.resolve_node(:ip => "1.2.3.4")).to eq("1.2.3.4")
     end

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/http'
@@ -5,13 +6,13 @@ require 'puppet/network/http/connection'
 
 describe Puppet::Network::HTTP::NoCachePool do
   let(:site) { Puppet::Network::HTTP::Site.new('https', 'rubygems.org', 443) }
-  let(:verify) { double('verify', :setup_connection => nil) }
+  let(:verify) { stub('verify', :setup_connection => nil) }
 
   it 'yields a connection' do
-    http  = double('http')
+    http  = stub('http')
 
     factory = Puppet::Network::HTTP::Factory.new
-    allow(factory).to receive(:create_connection).and_return(http)
+    factory.stubs(:create_connection).returns(http)
     pool = Puppet::Network::HTTP::NoCachePool.new(factory)
 
     expect { |b|
@@ -20,11 +21,11 @@ describe Puppet::Network::HTTP::NoCachePool do
   end
 
   it 'yields a new connection each time' do
-    http1  = double('http1')
-    http2  = double('http2')
+    http1  = stub('http1')
+    http2  = stub('http2')
 
     factory = Puppet::Network::HTTP::Factory.new
-    allow(factory).to receive(:create_connection).and_return(http1, http2)
+    factory.stubs(:create_connection).returns(http1).then.returns(http2)
     pool = Puppet::Network::HTTP::NoCachePool.new(factory)
 
     expect { |b|

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'openssl'
@@ -19,7 +20,7 @@ describe Puppet::Network::HTTP::Pool do
   end
 
   let(:verify) do
-    double('verify', :setup_connection => nil)
+    stub('verify', :setup_connection => nil)
   end
 
   def create_pool
@@ -45,7 +46,7 @@ describe Puppet::Network::HTTP::Pool do
   end
 
   def create_connection(site)
-    double(site.addr, :started? => false, :start => nil, :finish => nil, :use_ssl? => true, :verify_mode => OpenSSL::SSL::VERIFY_PEER)
+    stub(site.addr, :started? => false, :start => nil, :finish => nil, :use_ssl? => true, :verify_mode => OpenSSL::SSL::VERIFY_PEER)
   end
 
   context 'when yielding a connection' do
@@ -60,8 +61,6 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'returns the connection to the pool' do
       conn = create_connection(site)
-      expect(conn).to receive(:started?).and_return(true)
-
       pool = create_pool
       pool.release(site, conn)
 
@@ -103,7 +102,7 @@ describe Puppet::Network::HTTP::Pool do
       pool = create_pool
       pool.release(site, conn)
 
-      expect(pool).not_to receive(:release).with(site, conn)
+      pool.expects(:release).with(site, conn).never
 
       pool.with_connection(site, verify) do |c|
         raise IOError, 'connection reset'
@@ -138,51 +137,36 @@ describe Puppet::Network::HTTP::Pool do
     context 'when releasing connections' do
       it 'releases HTTP connections' do
         conn = create_connection(site)
-        expect(conn).to receive(:use_ssl?).and_return(false)
-        expect(conn).to receive(:started?).and_return(true)
+        conn.expects(:use_ssl?).returns(false)
 
         pool = create_pool_with_connections(site, conn)
-        expect(pool).to receive(:release).with(site, conn)
+        pool.expects(:release).with(site, conn)
 
         pool.with_connection(site, verify) {|c| }
       end
 
       it 'releases secure HTTPS connections' do
         conn = create_connection(site)
-        expect(conn).to receive(:use_ssl?).and_return(true)
-        expect(conn).to receive(:verify_mode).and_return(OpenSSL::SSL::VERIFY_PEER)
-        expect(conn).to receive(:started?).and_return(true)
+        conn.expects(:use_ssl?).returns(true)
+        conn.expects(:verify_mode).returns(OpenSSL::SSL::VERIFY_PEER)
 
         pool = create_pool_with_connections(site, conn)
-        expect(pool).to receive(:release).with(site, conn)
+        pool.expects(:release).with(site, conn)
 
         pool.with_connection(site, verify) {|c| }
       end
 
       it 'closes insecure HTTPS connections' do
         conn = create_connection(site)
-        expect(conn).to receive(:use_ssl?).and_return(true)
-        expect(conn).to receive(:verify_mode).and_return(OpenSSL::SSL::VERIFY_NONE)
+        conn.expects(:use_ssl?).returns(true)
+        conn.expects(:verify_mode).returns(OpenSSL::SSL::VERIFY_NONE)
 
         pool = create_pool_with_connections(site, conn)
 
-        expect(pool).not_to receive(:release).with(site, conn)
+        pool.expects(:release).with(site, conn).never
 
         pool.with_connection(site, verify) {|c| }
       end
-
-      it "doesn't add a closed  connection back to the pool" do
-        http = Net::HTTP.new(site.addr)
-        http.use_ssl = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        http.start
-
-        pool = create_pool_with_connections(site, http)
-
-        pool.with_connection(site, verify) {|c| c.finish}
-
-        expect(pool.pool[site]).to be_empty
-      end
     end
   end
 
@@ -190,8 +174,8 @@ describe Puppet::Network::HTTP::Pool do
     it 'returns a new connection if the pool is empty' do
       conn = create_connection(site)
       pool = create_pool
-      expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
-      expect(pool).to receive(:setsockopts)
+      pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -200,7 +184,7 @@ describe Puppet::Network::HTTP::Pool do
       conn = create_connection(site)
       pool = create_pool_with_connections(site, conn)
 
-      expect(pool.factory).not_to receive(:create_connection)
+      pool.factory.expects(:create_connection).never
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -210,26 +194,26 @@ describe Puppet::Network::HTTP::Pool do
       pool = create_pool_with_connections(different_site, different_conn)
 
       conn = create_connection(site)
-      expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
-      expect(pool).to receive(:setsockopts)
+      pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
 
     it 'returns started connections' do
       conn = create_connection(site)
-      expect(conn).to receive(:start)
+      conn.expects(:start)
 
       pool = create_pool
-      expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
-      expect(pool).to receive(:setsockopts)
+      pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
 
     it "doesn't start a cached connection" do
       conn = create_connection(site)
-      expect(conn).not_to receive(:start)
+      conn.expects(:start).never
 
       pool = create_pool_with_connections(site, conn)
       pool.borrow(site, verify)
@@ -245,26 +229,24 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'finishes expired connections' do
       conn = create_connection(site)
-      allow(conn).to receive(:started?).and_return(true)
-      expect(conn).to receive(:finish)
+      conn.expects(:finish)
 
       pool = create_pool_with_expired_connections(site, conn)
-      expect(pool.factory).to receive(:create_connection).and_return(double('conn', :start => nil))
-      expect(pool).to receive(:setsockopts)
+      pool.factory.expects(:create_connection => stub('conn', :start => nil))
+      pool.expects(:setsockopts)
 
       pool.borrow(site, verify)
     end
 
     it 'logs an exception if it fails to close an expired connection' do
-      expect(Puppet).to receive(:log_exception).with(be_a(IOError), "Failed to close connection for #{site}: read timeout")
+      Puppet.expects(:log_exception).with(is_a(IOError), "Failed to close connection for #{site}: read timeout")
 
       conn = create_connection(site)
-      expect(conn).to receive(:started?).and_return(true)
-      expect(conn).to receive(:finish).and_raise(IOError, 'read timeout')
+      conn.expects(:finish).raises(IOError, 'read timeout')
 
       pool = create_pool_with_expired_connections(site, conn)
-      expect(pool.factory).to receive(:create_connection).and_return(double('open_conn', :start => nil))
-      expect(pool).to receive(:setsockopts)
+      pool.factory.expects(:create_connection => stub('open_conn', :start => nil))
+      pool.expects(:setsockopts)
 
       pool.borrow(site, verify)
     end
@@ -308,23 +290,10 @@ describe Puppet::Network::HTTP::Pool do
 
     it 'closes all cached connections' do
       conn = create_connection(site)
-      allow(conn).to receive(:started?).and_return(true)
-      expect(conn).to receive(:finish)
+      conn.expects(:finish)
 
       pool = create_pool_with_connections(site, conn)
       pool.close
     end
-
-    it 'allows a connection to be closed multiple times safely' do
-      http = Net::HTTP.new(site.addr)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      http.start
-
-      pool = create_pool
-
-      expect(pool.close_connection(site, http)).to eq(true)
-      expect(pool.close_connection(site, http)).to eq(false)
-    end
   end
 end

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

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 require 'puppet_spec/network'
 require 'puppet/network/http'

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

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_spec/handler'
@@ -15,14 +17,14 @@ describe Puppet::Network::HTTP::Response do
 
   context "when passed a response body" do
     it "passes the status code and body to the handler" do
-      expect(handler).to receive(:set_response).with(response, body_utf8, 200)
+      handler.expects(:set_response).with(response, body_utf8, 200)
 
       subject.respond_with(200, 'application/json', body_utf8)
     end
 
     it "accepts a File body" do
       file = tmpfile('response_spec')
-      expect(handler).to receive(:set_response).with(response, file, 200)
+      handler.expects(:set_response).with(response, file, 200)
 
       subject.respond_with(200, 'application/octet-stream', file)
     end
@@ -30,14 +32,14 @@ describe Puppet::Network::HTTP::Response do
 
   context "when passed a content type" do
     it "accepts a mime string" do
-      expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
+      handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
 
       subject.respond_with(200, 'application/json', body_utf8)
     end
 
     it "accepts a format object" do
       formatter = Puppet::Network::FormatHandler.format(:json)
-      expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
+      handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
 
       subject.respond_with(200, formatter, body_utf8)
     end
@@ -49,7 +51,7 @@ describe Puppet::Network::HTTP::Response do
         body_binary = [0xDEADCAFE].pack('L')
 
         formatter = Puppet::Network::FormatHandler.format(:binary)
-        expect(handler).to receive(:set_content_type).with(response, 'application/octet-stream')
+        handler.expects(:set_content_type).with(response, 'application/octet-stream')
 
         subject.respond_with(200, formatter, body_binary)
       end
@@ -61,14 +63,14 @@ describe Puppet::Network::HTTP::Response do
       it "sets the charset to UTF-8 for content already in that format" do
         body_pem = "BEGIN CERTIFICATE".encode('UTF-8')
 
-        expect(handler).to receive(:set_content_type).with(response, 'text/plain; charset=utf-8')
+        handler.expects(:set_content_type).with(response, 'text/plain; charset=utf-8')
 
         subject.respond_with(200, formatter, body_pem)
       end
 
       it "encodes the content to UTF-8 for content not already in UTF-8" do
-        expect(handler).to receive(:set_content_type).with(response, 'text/plain; charset=utf-8')
-        expect(handler).to receive(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
+        handler.expects(:set_content_type).with(response, 'text/plain; charset=utf-8')
+        handler.expects(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
 
         subject.respond_with(200, formatter, body_shift_jis)
       end
@@ -84,14 +86,14 @@ describe Puppet::Network::HTTP::Response do
       let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
 
       it "sets the charset to UTF-8 for content already in that format" do
-        expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
+        handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
 
         subject.respond_with(200, formatter, body_utf8)
       end
 
       it "encodes the content to UTF-8 for content not already in UTF-8" do
-        expect(handler).to receive(:set_content_type).with(response, 'application/json; charset=utf-8')
-        expect(handler).to receive(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
+        handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+        handler.expects(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
 
         subject.respond_with(200, formatter, body_shift_jis)
       end