puppet 6.13.0-x64-mingw32 → 6.18.0-x64-mingw32

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

@@ -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)
@@ -174,7 +186,7 @@ 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
+      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
@@ -184,7 +196,7 @@ describe Puppet::Network::HTTP::Pool do
 
         pool.with_connection(site, verifier) {|c| c.finish}
 
-        expect(pool.pool[site]).to be_empty
+        expect(pool.pool[site]).to be_nil
       end
     end
   end
@@ -194,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
@@ -214,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)
@@ -237,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)
 
@@ -246,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
@@ -279,8 +319,7 @@ describe Puppet::Network::HTTP::Pool do
       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
@@ -293,11 +332,18 @@ describe Puppet::Network::HTTP::Pool do
       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
 
   context 'when releasing a connection' do

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,39 @@ 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, :load_as_module?).new('bolt_project', path, true)
+
+            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
+
+          it "does not include the Bolt project in modules if load_as_module? is false" do
+            path = tmpdir('project')
+            PuppetSpec::Modules.generate_files('bolt_project', path)
+            project = Struct.new("Project", :name, :path, :load_as_module?).new('bolt_project', path, false)
+
+            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{foo bar bee baz}.sort)
+            end
+
+          end
         end
       end
     end

data/spec/unit/parser/ast/block_expression_spec.rb

@@ -12,7 +12,7 @@ describe 'Puppet::Parser::AST::BlockExpression' do
   NO_SCOPE = nil
 
   def depth_probe
-    StackDepthAST.new({})
+    StackDepthAST.new
   end
 
   def sequence_probe(name)

data/spec/unit/parser/environment_compiler_spec.rb

@@ -366,6 +366,13 @@ EOS
       }.to raise_error(/'Cap\[cap\]' is exported by both 'Prod\[one\]' and 'Prod\[two\]'/)
     end
 
+    it "issues deprecation warnings" do
+      expect {compile_collect_log(MANIFEST_WO_NODE)}.not_to raise_error
+      expect(warnings).to include(/Capability Mapping is deprecated/) # there are two of these
+      expect(warnings).to include(/Application is deprecated/)
+      expect(warnings).to include(/Site Definition is deprecated/)
+    end
+
     context "for producing node" do
       let(:compiled_node) { Puppet::Node.new('first', :environment => env) }
       let(:compiled_catalog) { compile_to_catalog(MANIFEST, compiled_node)}

data/spec/unit/parser/scope_spec.rb

@@ -105,7 +105,7 @@ describe Puppet::Parser::Scope do
 
   it "should fail if something that isn't a compiler is supplied" do
     expect {
-      Puppet::Parser::Scope.new(:compiler => true)
+      Puppet::Parser::Scope.new(nil)
     }.to raise_error(Puppet::DevError, /you must pass a compiler instance/)
   end
 

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -1578,7 +1578,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       let(:applicator) { double('apply_executor') }
 
       it 'invokes an apply_executor' do
-        expect(applicator).to receive(:apply).with(['arg1', 'arg2'], nil, scope).and_return(:result)
+        expect(applicator).to receive(:apply).with(
+          ['arg1', 'arg2'],
+          instance_of(Puppet::Pops::Model::BlockExpression),
+          scope).and_return(:result)
         src = "apply('arg1', 'arg2') { }"
         Puppet.override(apply_executor: applicator) do
           expect(parser.evaluate_string(scope, src)).to eq(:result)
@@ -1595,6 +1598,17 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
           expect(parser.evaluate_string(scope, src)).to eq(:result)
         end
       end
+
+      it 'returns a BlockExpression with an empty apply block' do
+        expect(applicator).to receive(:apply).with(
+          [['arg1']],
+          instance_of(Puppet::Pops::Model::BlockExpression),
+          scope).and_return(:result)
+        src = "apply(['arg1']) { }"
+        Puppet.override(apply_executor: applicator) do
+          expect(parser.evaluate_string(scope, src)).to eq(:result)
+        end
+      end
     end
   end