puppet 6.11.1-x64-mingw32 → 6.16.0-x64-mingw32

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

@@ -8,7 +8,7 @@ describe Puppet::Network::HTTP::NoCachePool do
   let(:verifier) { double('verifier', :setup_connection => nil) }
 
   it 'yields a started connection' do
-    http  = double('http', start: nil, finish: nil)
+    http  = double('http', start: nil, finish: nil, started?: true)
 
     factory = Puppet::Network::HTTP::Factory.new
     allow(factory).to receive(:create_connection).and_return(http)
@@ -20,8 +20,8 @@ describe Puppet::Network::HTTP::NoCachePool do
   end
 
   it 'yields a new connection each time' do
-    http1  = double('http1', start: nil, finish: nil)
-    http2  = double('http2', start: nil, finish: nil)
+    http1  = double('http1', start: nil, finish: nil, started?: true)
+    http2  = double('http2', start: nil, finish: nil, started?: true)
 
     factory = Puppet::Network::HTTP::Factory.new
     allow(factory).to receive(:create_connection).and_return(http1, http2)
@@ -39,4 +39,26 @@ describe Puppet::Network::HTTP::NoCachePool do
   it 'has a close method' do
     Puppet::Network::HTTP::NoCachePool.new.close
   end
+
+  it 'logs a deprecation warning' do
+    http  = double('http', start: nil, finish: nil, started?: true)
+
+    factory = Puppet::Network::HTTP::Factory.new
+    allow(factory).to receive(:create_connection).and_return(http)
+    Puppet::Network::HTTP::NoCachePool.new(factory)
+
+    expect(@logs).to include(an_object_having_attributes(level: :warning, message: /Puppet::Network::HTTP::NoCachePool is deprecated/))
+  end
+
+  it 'omits the warning when deprecations are disabled' do
+    Puppet[:disable_warnings] = 'deprecations'
+
+    http  = double('http', start: nil, finish: nil, started?: true)
+
+    factory = Puppet::Network::HTTP::Factory.new
+    allow(factory).to receive(:create_connection).and_return(http)
+    Puppet::Network::HTTP::NoCachePool.new(factory)
+
+    expect(@logs).to eq([])
+  end
 end

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

@@ -26,17 +26,25 @@ describe Puppet::Network::HTTP::Pool do
   end
 
   def create_pool
-    Puppet::Network::HTTP::Pool.new
+    Puppet::Network::HTTP::Pool.new(15)
   end
 
   def create_pool_with_connections(site, *connections)
-    pool = Puppet::Network::HTTP::Pool.new
+    pool = Puppet::Network::HTTP::Pool.new(15)
     connections.each do |conn|
       pool.release(site, verifier, conn)
     end
     pool
   end
 
+  def create_pool_with_http_connections(site, *connections)
+    pool = Puppet::Network::HTTP::Pool.new(15)
+    connections.each do |conn|
+      pool.release(site, nil, conn)
+    end
+    pool
+  end
+
   def create_pool_with_expired_connections(site, *connections)
     # setting keepalive timeout to -1 ensures any newly added
     # connections have already expired
@@ -51,6 +59,10 @@ describe Puppet::Network::HTTP::Pool do
     double(site.addr, :started? => false, :start => nil, :finish => nil, :use_ssl? => true, :verify_mode => OpenSSL::SSL::VERIFY_PEER)
   end
 
+  def create_http_connection(site)
+    double(site.addr, :started? => false, :start => nil, :finish => nil, :use_ssl? => false)
+  end
+
   context 'when yielding a connection' do
     it 'yields a connection' do
       conn = create_connection(site)
@@ -63,6 +75,8 @@ 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, verifier, conn)
 
@@ -140,6 +154,7 @@ describe Puppet::Network::HTTP::Pool 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)
 
         pool = create_pool_with_connections(site, conn)
         expect(pool).to receive(:release).with(site, verifier, conn)
@@ -151,6 +166,7 @@ describe Puppet::Network::HTTP::Pool 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)
 
         pool = create_pool_with_connections(site, conn)
         expect(pool).to receive(:release).with(site, verifier, conn)
@@ -169,6 +185,19 @@ describe Puppet::Network::HTTP::Pool do
 
         pool.with_connection(site, verifier) {|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, verifier) {|c| c.finish}
+
+        expect(pool.pool[site]).to be_nil
+      end
     end
   end
 
@@ -177,7 +206,6 @@ describe Puppet::Network::HTTP::Pool 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)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
@@ -197,15 +225,37 @@ describe Puppet::Network::HTTP::Pool do
 
       conn = create_connection(site)
       expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
-      expect(pool).to receive(:setsockopts)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
 
+    it 'returns a new HTTP connection if the cached connection is HTTPS' do
+      https_site = Puppet::Network::HTTP::Site.new('https', 'www.example.com', 443)
+      old_conn = create_connection(https_site)
+      pool = create_pool_with_connections(https_site, old_conn)
+
+      http_site = Puppet::Network::HTTP::Site.new('http', 'www.example.com', 443)
+      new_conn = create_http_connection(http_site)
+      allow(pool.factory).to receive(:create_connection).with(http_site).and_return(new_conn)
+
+      expect(pool.borrow(http_site, nil)).to eq(new_conn)
+    end
+
+    it 'returns a new HTTPS connection if the cached connection is HTTP' do
+      http_site = Puppet::Network::HTTP::Site.new('http', 'www.example.com', 443)
+      old_conn = create_http_connection(http_site)
+      pool = create_pool_with_http_connections(http_site, old_conn)
+
+      https_site = Puppet::Network::HTTP::Site.new('https', 'www.example.com', 443)
+      new_conn = create_connection(https_site)
+      allow(pool.factory).to receive(:create_connection).with(https_site).and_return(new_conn)
+
+      expect(pool.borrow(https_site, verifier)).to eq(new_conn)
+    end
+
     it 'returns a new connection if the ssl contexts are different' do
       old_conn = create_connection(site)
       pool = create_pool_with_connections(site, old_conn)
-      allow(pool).to receive(:setsockopts)
 
       new_conn = create_connection(site)
       allow(pool.factory).to receive(:create_connection).with(site).and_return(new_conn)
@@ -220,7 +270,6 @@ describe Puppet::Network::HTTP::Pool do
     it 'returns a cached connection if the ssl contexts are the same' do
       old_conn = create_connection(site)
       pool = create_pool_with_connections(site, old_conn)
-      allow(pool).to receive(:setsockopts)
 
       expect(pool.factory).not_to receive(:create_connection)
 
@@ -229,13 +278,21 @@ describe Puppet::Network::HTTP::Pool do
       expect(pool.borrow(site, new_verifier)).to equal(old_conn)
     end
 
+    it 'returns a cached connection if both connections are http' do
+      http_site = Puppet::Network::HTTP::Site.new('http', 'www.example.com', 80)
+      old_conn = create_http_connection(http_site)
+      pool = create_pool_with_http_connections(http_site, old_conn)
+
+      # 'equal' tests that it's the same object
+      expect(pool.borrow(http_site, nil)).to equal(old_conn)
+    end
+
     it 'returns started connections' do
       conn = create_connection(site)
       expect(conn).to receive(:start)
 
       pool = create_pool
       expect(pool.factory).to receive(:create_connection).with(site).and_return(conn)
-      expect(pool).to receive(:setsockopts)
 
       expect(pool.borrow(site, verifier)).to eq(conn)
     end
@@ -258,11 +315,11 @@ 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)
 
       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)
+      expect(pool.factory).to receive(:create_connection).and_return(double('conn', :start => nil, :use_ssl? => true))
 
       pool.borrow(site, verifier)
     end
@@ -271,13 +328,21 @@ describe Puppet::Network::HTTP::Pool do
       expect(Puppet).to receive(:log_exception).with(be_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')
 
       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)
+      expect(pool.factory).to receive(:create_connection).and_return(double('open_conn', :start => nil, :use_ssl? => true))
+
+      pool.borrow(site, verifier)
+    end
 
+    it 'deletes the session when the last connection is borrowed' do
+      conn = create_connection(site)
+      pool = create_pool_with_connections(site, conn)
       pool.borrow(site, verifier)
+
+      expect(pool.pool[site]).to be_nil
     end
   end
 
@@ -319,10 +384,23 @@ 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)
 
       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_pool_spec.rb

@@ -1,41 +1,65 @@
 require 'spec_helper'
 require 'puppet/network/http_pool'
 
+class Puppet::Network::HttpPool::FooClient
+  def initialize(host, port, options = {})
+    @host = host
+    @port = port
+  end
+  attr_reader :host, :port
+end
+
 describe Puppet::Network::HttpPool do
-  before :each do
-    Puppet::SSL::Key.indirection.terminus_class = :memory
-    Puppet::SSL::CertificateRequest.indirection.terminus_class = :memory
+  include PuppetSpec::Files
+
+  describe "when registering an http client class" do
+    let(:http_impl) { Puppet::Network::HttpPool::FooClient }
+
+    around :each do |example|
+      orig_class = Puppet::Network::HttpPool.http_client_class
+      begin
+        example.run
+      ensure
+        Puppet::Network::HttpPool.http_client_class = orig_class
+      end
+    end
+
+    it "returns instances of the http client class" do
+      Puppet::Network::HttpPool.http_client_class = http_impl
+      http = Puppet::Network::HttpPool.http_instance("me", 54321)
+      expect(http).to be_an_instance_of(http_impl)
+      expect(http.host).to eq('me')
+      expect(http.port).to eq(54321)
+    end
+
+    it "uses the default http client" do
+      expect(Puppet.runtime[:http]).to be_an_instance_of(Puppet::HTTP::Client)
+    end
+
+    it "switches to the external client implementation" do
+      Puppet::Network::HttpPool.http_client_class = http_impl
+
+      expect(Puppet.runtime[:http]).to be_an_instance_of(Puppet::HTTP::ExternalClient)
+    end
+
+    it "always uses an explicitly registered http implementation" do
+      Puppet::Network::HttpPool.http_client_class = http_impl
+
+      new_impl = double('new_http_impl')
+      Puppet.initialize_settings([], true, true, http: new_impl)
+
+      expect(Puppet.runtime[:http]).to eq(new_impl)
+    end
   end
 
   describe "when managing http instances" do
     it "should return an http instance created with the passed host and port" do
       http = Puppet::Network::HttpPool.http_instance("me", 54321)
-      expect(http).to be_an_instance_of Puppet::Network::HTTP::Connection
+      expect(http).to be_a_kind_of Puppet::Network::HTTP::Connection
       expect(http.address).to eq('me')
       expect(http.port).to    eq(54321)
     end
 
-    it "should support using an alternate http client implementation" do
-      begin
-        class FooClient
-          def initialize(host, port, options = {})
-            @host = host
-            @port = port
-          end
-          attr_reader :host, :port
-        end
-
-        orig_class = Puppet::Network::HttpPool.http_client_class
-        Puppet::Network::HttpPool.http_client_class = FooClient
-        http = Puppet::Network::HttpPool.http_instance("me", 54321)
-        expect(http).to be_an_instance_of FooClient
-        expect(http.host).to eq('me')
-        expect(http.port).to eq(54321)
-      ensure
-        Puppet::Network::HttpPool.http_client_class = orig_class
-      end
-    end
-
     it "should enable ssl on the http instance by default" do
       expect(Puppet::Network::HttpPool.http_instance("me", 54321)).to be_use_ssl
     end
@@ -82,53 +106,35 @@ describe Puppet::Network::HttpPool do
     end
 
     describe 'peer verification' do
-      def setup_standard_ssl_configuration
-        ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
-
-        Puppet[:ssl_client_ca_auth] = ca_cert_file
-        allow(Puppet::FileSystem).to receive(:exist?).with(ca_cert_file).and_return(true)
-      end
-
-      def setup_standard_hostcert
-        host_cert_file = File.expand_path('/path/to/ssl/certs/host_cert.pem')
-        allow(Puppet::FileSystem).to receive(:exist?).with(host_cert_file).and_return(true)
-
-        Puppet[:hostcert] = host_cert_file
-      end
-
-      def setup_standard_ssl_host
-        cert = double('cert', :content => 'real_cert')
-        key  = double('key',  :content => 'real_key')
-        host = double('host', :certificate => cert, :key => key, :ssl_store => double('store'))
 
-        allow(Puppet::SSL::Host).to receive(:localhost).and_return(host)
-      end
+      before(:each) do
+        Puppet[:ssldir] = tmpdir('ssl')
+        Puppet.settings.use(:main)
 
-      before do
-        setup_standard_ssl_configuration
-        setup_standard_hostcert
-        setup_standard_ssl_host
+        Puppet[:certname] = 'signed'
+        File.write(Puppet[:localcacert], cert_fixture('ca.pem'))
+        File.write(Puppet[:hostcrl], crl_fixture('crl.pem'))
+        File.write(Puppet[:hostcert], cert_fixture('signed.pem'))
+        File.write(Puppet[:hostprivkey], key_fixture('signed-key.pem'))
       end
 
       it 'enables peer verification by default' do
-        response = Net::HTTPOK.new('1.1', 200, 'body')
+        stub_request(:get, "https://me:54321")
+
         conn = Puppet::Network::HttpPool.http_instance("me", 54321, true)
-        expect(conn).to receive(:execute_request) do |http, _|
+        expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
           expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
-
-          response
         end
 
         conn.get('/')
       end
 
       it 'can disable peer verification' do
-        response = Net::HTTPOK.new('1.1', 200, 'body')
+        stub_request(:get, "https://me:54321")
+
         conn = Puppet::Network::HttpPool.http_instance("me", 54321, true, false)
-        expect(conn).to receive(:execute_request) do |http, _|
+        expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
           expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
-
-          response
         end
 
         conn.get('/')

data/spec/unit/network/http_spec.rb

@@ -4,6 +4,6 @@ require 'puppet/network/http'
 describe Puppet::Network::HTTP do
   it 'defines an http_pool context' do
     pool = Puppet.lookup(:http_pool)
-    expect(pool).to be_a(Puppet::Network::HTTP::NoCachePool)
+    expect(pool).to be_a(Puppet::Network::HTTP::Pool)
   end
 end

data/spec/unit/node/environment_spec.rb

@@ -422,6 +422,22 @@ describe Puppet::Node::Environment do
 
             env.modules
           end
+
+          it "includes the Bolt project in modules if it's defined" do
+            path = tmpdir('project')
+            PuppetSpec::Modules.generate_files('bolt_project', path)
+            project = Struct.new("Project", :name, :path).new('bolt_project', path)
+
+            Puppet.override(bolt_project: project) do
+              %w{foo bar}.each do |mod_name|
+                PuppetSpec::Modules.generate_files(mod_name, first_modulepath)
+              end
+              %w{bee baz}.each do |mod_name|
+                PuppetSpec::Modules.generate_files(mod_name, second_modulepath)
+              end
+              expect(env.modules.collect{|mod| mod.name}.sort).to eq(%w{bolt_project foo bar bee baz}.sort)
+            end
+          end
         end
       end
     end