puppet 6.14.0 → 6.19.0

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,11 +26,11 @@ 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
@@ -38,7 +38,7 @@ describe Puppet::Network::HTTP::Pool do
   end
 
   def create_pool_with_http_connections(site, *connections)
-    pool = Puppet::Network::HTTP::Pool.new
+    pool = Puppet::Network::HTTP::Pool.new(15)
     connections.each do |conn|
       pool.release(site, nil, conn)
     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,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
 

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -92,6 +92,35 @@ describe 'loaders' do
     it 'errors with message about empty file for files that contain no logic' do
       expect{loader.load(:resource_type_pp, 'empty')}.to raise_error(ArgumentError, /it is empty/)
     end
+
+    it 'creates a pcore resource type loader' do
+      pcore_loader = env.loaders.runtime3_type_loader.resource_3x_loader
+      expect(pcore_loader.loader_name).to eq('pcore_resource_types')
+      expect(pcore_loader).to be_a(Puppet::Pops::Loader::ModuleLoaders::FileBased)
+    end
+
+    it 'does not create a pcore resource type loader if requested not to' do
+      env.loaders = nil # clear cached loaders
+      loaders = Puppet::Pops::Loaders.new(env, false, false)
+      expect(loaders.runtime3_type_loader.resource_3x_loader).to be_nil
+    end
+
+    it 'does not create a pcore resource type loader for an empty environment' do
+      loaders = Puppet::Pops::Loaders.new(empty_test_env)
+      expect(loaders.runtime3_type_loader.resource_3x_loader).to be_nil
+    end
+  end
+
+  def expect_loader_hierarchy(loaders, expected_loaders)
+    actual_loaders = []
+
+    loader = loaders.private_environment_loader
+    while loader
+      actual_loaders << [loader.loader_name, loader]
+      loader = loader.parent
+    end
+
+    expect(actual_loaders).to contain_exactly(*expected_loaders)
   end
 
   it 'creates a puppet_system loader' do
@@ -123,6 +152,47 @@ describe 'loaders' do
     expect(loaders.private_environment_loader().to_s).to eql("(DependencyLoader 'environment private' [])")
   end
 
+  it 'creates a hierarchy of loaders' do
+    expect_loader_hierarchy(
+      Puppet::Pops::Loaders.new(empty_test_env),
+      [
+        [nil,                   Puppet::Pops::Loader::StaticLoader],
+        ['puppet_system',       Puppet::Pops::Loader::ModuleLoaders::LibRootedFileBased],
+        [empty_test_env.name,   Puppet::Pops::Loader::Runtime3TypeLoader],
+        ['environment',         Puppet::Pops::Loader::SimpleEnvironmentLoader],
+        ['environment private', Puppet::Pops::Loader::DependencyLoader],
+      ]
+    )
+  end
+
+  it 'excludes the Runtime3TypeLoader when tasks are enabled' do
+    Puppet[:tasks] = true
+
+    expect_loader_hierarchy(
+      Puppet::Pops::Loaders.new(empty_test_env),
+      [
+        [nil,                   Puppet::Pops::Loader::StaticLoader],
+        ['puppet_system',       Puppet::Pops::Loader::ModuleLoaders::LibRootedFileBased],
+        ['environment',         Puppet::Pops::Loader::ModuleLoaders::EmptyLoader],
+        ['environment private', Puppet::Pops::Loader::DependencyLoader],
+      ]
+    )
+  end
+
+  it 'includes the agent cache loader when for_agent is true' do
+    expect_loader_hierarchy(
+      Puppet::Pops::Loaders.new(empty_test_env, true),
+      [
+        [nil,                   Puppet::Pops::Loader::StaticLoader],
+        ['puppet_system',       Puppet::Pops::Loader::ModuleLoaders::LibRootedFileBased],
+        ['cached_puppet_lib',   Puppet::Pops::Loader::ModuleLoaders::LibRootedFileBased],
+        [empty_test_env.name,   Puppet::Pops::Loader::Runtime3TypeLoader],
+        ['environment',         Puppet::Pops::Loader::SimpleEnvironmentLoader],
+        ['environment private', Puppet::Pops::Loader::DependencyLoader],
+      ],
+    )
+  end
+
   context 'when loading from a module' do
     it 'loads a ruby function using a qualified or unqualified name' do
       loaders = Puppet::Pops::Loaders.new(environment_for(module_with_metadata))
@@ -461,7 +531,7 @@ describe 'loaders' do
     it "a function with syntax error has helpful error message" do
       expect {
         loader.load_typed(typed_name(:function, 'func_with_syntax_error'))
-      }.to raise_error(/syntax error, unexpected (keyword_)?end/)
+      }.to raise_error(/syntax error, unexpected (keyword_|`)?end/)
     end
   end
 

data/spec/unit/pops/lookup/lookup_spec.rb

@@ -14,6 +14,7 @@ describe 'The lookup API' do
   let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, 'modules')]) }
   let(:node) { Puppet::Node.new('test', :environment => env) }
   let(:compiler) { Puppet::Parser::Compiler.new(node) }
+  let(:pal_compiler) { Puppet::Pal::ScriptCompiler.new(compiler) }
   let(:scope) { compiler.topscope }
   let(:invocation) { Invocation.new(scope) }
 
@@ -345,6 +346,30 @@ describe 'The lookup API' do
       end
     end
   end
+
+  context 'when using plan_hierarchy' do
+    let(:code_dir_content) do
+      {
+        'hiera.yaml' => <<-YAML.unindent,
+        version: 5
+        plan_hierarchy:
+          - path: foo.yaml
+            name: Common
+        YAML
+        'data' => {
+          'foo.yaml' => <<-YAML.unindent
+          pop: star
+          YAML
+        }
+      }
+    end
+
+    it 'uses plan_hierarchy when using ScriptCompiler' do
+      Puppet.override(pal_compiler: pal_compiler) do
+        expect(Lookup.lookup('pop', nil, nil, true, nil, invocation)).to eq('star')
+      end
+    end
+  end
 end
 end
 end