puppet 6.16.0-x64-mingw32 → 7.0.0-x64-mingw32

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

@@ -2,7 +2,6 @@ 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
@@ -102,11 +101,6 @@ describe Puppet::Network::HTTP::Handler do
       { :status => 200 }
     end
 
-    before do
-      allow(handler).to receive(:check_authorization)
-      allow(handler).to receive(:warn_if_near_expiration)
-    end
-
     it "should setup a profiler when the puppet-profiling header exists" do
       request = a_request
       request[:headers][Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase] = "true"

data/spec/unit/network/http_pool_spec.rb

@@ -69,10 +69,6 @@ describe Puppet::Network::HttpPool do
       expect(Puppet::Network::HttpPool.http_instance("me", 54321, true)).to be_use_ssl
     end
 
-    it 'has an http_ssl_instance method' do
-      expect(Puppet::Network::HttpPool.http_ssl_instance("me", 54321)).to be_use_ssl
-    end
-
     context "when calling 'connection'" do
       it 'requires an ssl_context' do
         expect {

data/spec/unit/node/environment_spec.rb

@@ -426,7 +426,7 @@ describe Puppet::Node::Environment do
           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)
+            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|
@@ -438,6 +438,23 @@ describe Puppet::Node::Environment do
               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
@@ -509,34 +526,46 @@ describe Puppet::Node::Environment do
   end
 
   describe "managing module translations" do
-    it "creates a new text domain the first time we try to use the text domain" do
-      expect(Puppet::GettextConfig).to receive(:reset_text_domain).with(env.name)
-      expect(Puppet::ModuleTranslations).to receive(:load_from_modulepath)
-      expect(Puppet::GettextConfig).to receive(:clear_text_domain)
+    context "when i18n is enabled" do
+      before(:each) do
+        Puppet[:disable_i18n] = false
+      end
 
-      env.with_text_domain do; end
-    end
+      it "yields block results" do
+        ran = false
+        expect(env.with_text_domain { ran = true; :result }).to eq(:result)
+        expect(ran).to eq(true)
+      end
 
-    it "uses the existing text domain once it has been created" do
-      env.with_text_domain do; end
+      it "creates a new text domain the first time we try to use the text domain" do
+        expect(Puppet::GettextConfig).to receive(:reset_text_domain).with(env.name)
+        expect(Puppet::ModuleTranslations).to receive(:load_from_modulepath)
+        expect(Puppet::GettextConfig).to receive(:clear_text_domain)
 
-      expect(Puppet::GettextConfig).to receive(:use_text_domain).with(env.name)
-      env.with_text_domain do; end
-    end
+        env.with_text_domain do; end
+      end
 
-    it "yields block results" do
-      ran = false
-      expect(env.with_text_domain { ran = true; :result }).to eq(:result)
-      expect(ran).to eq(true)
+      it "uses the existing text domain once it has been created" do
+        env.with_text_domain do; end
+
+        expect(Puppet::GettextConfig).to receive(:use_text_domain).with(env.name)
+        env.with_text_domain do; end
+      end
     end
 
-    it "yields block results when i18n is disabled" do
-      Puppet[:disable_i18n] = true
+    context "when i18n is disabled" do
+      it "yields block results" do
+        ran = false
+        expect(env.with_text_domain { ran = true; :result }).to eq(:result)
+        expect(ran).to eq(true)
+      end
+
+      it "does not create a new text domain the first time we try to use the text domain" do
+        expect(Puppet::GettextConfig).not_to receive(:reset_text_domain)
+        expect(Puppet::ModuleTranslations).not_to receive(:load_from_modulepath)
 
-      ran = false
-      expect(env.with_text_domain { ran = true; :result }).to eq(:result)
-      expect(ran).to eq(true)
+        env.with_text_domain do; end
+      end
     end
   end
-
 end

data/spec/unit/node_spec.rb

@@ -417,64 +417,12 @@ end
 
 describe Puppet::Node, "when generating the list of names to search through" do
   before do
-    Puppet[:strict_hostname_checking] = false
     @node = Puppet::Node.new("foo.domain.com",
                              :parameters => {"hostname" => "yay", "domain" => "domain.com"})
   end
 
-  it "returns an array of names" do
+  it "returns an array of one name" do
     expect(@node.names).to be_instance_of(Array)
-  end
-
-  describe "and the node name is fully qualified" do
-    it "contains an entry for each part of the node name" do
-      expect(@node.names).to include("foo.domain.com")
-      expect(@node.names).to include("foo.domain")
-      expect(@node.names).to include("foo")
-    end
-  end
-
-  it "includes the node's fqdn" do
-    expect(@node.names).to include("yay.domain.com")
-  end
-
-  it "combines and include the node's hostname and domain if no fqdn is available" do
-    expect(@node.names).to include("yay.domain.com")
-  end
-
-  it "contains an entry for each name available by stripping a segment of the fqdn" do
-    @node.parameters["fqdn"] = "foo.deep.sub.domain.com"
-    expect(@node.names).to include("foo.deep.sub.domain")
-    expect(@node.names).to include("foo.deep.sub")
-  end
-
-  describe "and :node_name is set to 'cert'" do
-    before do
-      Puppet[:node_name] = "cert"
-    end
-
-    it "uses the passed-in key as the first value" do
-      expect(@node.names[0]).to eq("foo.domain.com")
-    end
-
-    describe "and strict hostname checking is enabled" do
-      before do
-        Puppet[:strict_hostname_checking] = true
-      end
-
-      it "only uses the passed-in key" do
-        expect(@node.names).to eq(["foo.domain.com"])
-      end
-    end
-  end
-
-  describe "and :node_name is set to 'facter'" do
-    before do
-      Puppet[:node_name] = "facter"
-    end
-
-    it "uses the node's 'hostname' fact as the first value" do
-      expect(@node.names[0]).to eq("yay")
-    end
+    expect(@node.names).to eq ["foo.domain.com"]
   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/functions/create_resources_spec.rb

@@ -257,31 +257,13 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:class, "bar")).not_to be_nil
     end
 
-    [:off, :warning].each do | strictness |
-      it "should warn if strict = #{strictness} and class is exported" do
-        Puppet[:strict] = strictness
-        collect_notices('class test{} create_resources("@@class", {test => {}})')
-        expect(warnings).to include(/Classes are not virtualizable/)
-      end
-    end
-
-    it 'should error if strict = error and class is exported' do
-      Puppet[:strict] = :error
+    it 'should error if class is exported' do
       expect{
         compile_to_catalog('class test{} create_resources("@@class", {test => {}})')
       }.to raise_error(/Classes are not virtualizable/)
     end
 
-    [:off, :warning].each do | strictness |
-      it "should warn if strict = #{strictness} and class is virtual" do
-        Puppet[:strict] = strictness
-        collect_notices('class test{} create_resources("@class", {test => {}})')
-        expect(warnings).to include(/Classes are not virtualizable/)
-      end
-    end
-
-    it 'should error if strict = error and class is virtual' do
-      Puppet[:strict] = :error
+    it 'should error if class is virtual' do
       expect{
         compile_to_catalog('class test{} create_resources("@class", {test => {}})')
       }.to raise_error(/Classes are not virtualizable/)

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

@@ -818,14 +818,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
     end
 
-    # Integer for >= 2.4.0, otherwise Fixnum
-    int_class_name = 0.class.name
-
     # Errors when wrong number/type of keys are used
     {
-      "Array[0]"                    => "Array-Type[] arguments must be types. Got #{int_class_name}",
-      "Hash[0]"                     => "Hash-Type[] arguments must be types. Got #{int_class_name}",
-      "Hash[Integer, 0]"            => "Hash-Type[] arguments must be types. Got #{int_class_name}",
+      "Array[0]"                    => "Array-Type[] arguments must be types. Got Integer",
+      "Hash[0]"                     => "Hash-Type[] arguments must be types. Got Integer",
+      "Hash[Integer, 0]"            => "Hash-Type[] arguments must be types. Got Integer",
       "Array[Integer,1,2,3]"        => 'Array-Type[] accepts 1 to 3 arguments. Got 4',
       "Array[Integer,String]"       => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String-Type",
       "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 2 to 4 arguments. Got 5',
@@ -833,7 +830,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'abc'[1.0]"                  => "A substring operation does not accept a Float as a character index. Expected an Integer",
       "'abc'[1, x]"                 => "A substring operation does not accept a String as a character index. Expected an Integer",
       "'abc'[1,2,3]"                => "String supports [] with one or two arguments. Got 3",
-      "NotUndef[0]"                 => "NotUndef-Type[] argument must be a Type or a String. Got #{int_class_name}",
+      "NotUndef[0]"                 => "NotUndef-Type[] argument must be a Type or a String. Got Integer",
       "NotUndef[a,b]"               => 'NotUndef-Type[] accepts 0 to 1 arguments. Got 2',
       "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Integer',
       "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Integer where a resource title String is expected',
@@ -1578,7 +1575,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 +1595,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
 
@@ -505,27 +575,6 @@ describe 'loaders' do
     end
   end
 
-context 'when a 3x load has illegal construct and --func3x_check is false' do
-  let(:env) { environment_for(mix_4x_and_3x_functions) }
-  let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
-  let(:scope) { compiler.topscope }
-  let(:loader) { compiler.loaders.private_loader_for_module('user') }
-
-  before(:each) do
-    Puppet.push_context(:current_environment => scope.environment, :global_scope => scope, :loaders => compiler.loaders)
-    Puppet[:func3x_check] = false
-  end
-  after(:each) do
-    Puppet.pop_context
-    Puppet[:func3x_check] = true
-  end
-
-  it "an illegal function is loaded" do
-      f = loader.load_typed(typed_name(:function, 'bad_func_load3')).value
-      expect(f.call(scope)).to eql("some return value")
-  end
-end
-
   context 'when causing a 3x load followed by a 4x load' do
     let(:env) { environment_for(mix_4x_and_3x_functions) }
     let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
@@ -553,6 +602,12 @@ end
       function = loader.load_typed(typed_name(:function, 'callee_ws')).value
       expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'value'")
     end
+
+    it "an illegal function is loaded" do
+      expect {
+        loader.load_typed(typed_name(:function, 'bad_func_load3')).value
+      }.to raise_error(SecurityError, /Illegal method definition of method 'bad_func_load3_illegal_method' on line 8 in legacy function/)
+    end
   end
 
   context 'loading' do

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