puppet 6.17.0-universal-darwin → 6.21.0-universal-darwin

data/spec/unit/indirector_spec.rb

@@ -112,8 +112,8 @@ describe Puppet::Indirector, "when registering an indirection" do
   end
 
   it "should pass any provided options to the indirection during initialization" do
-    expect(Puppet::Indirector::Indirection).to receive(:new).with(@thingie, :first, {:some => :options, :indirected_class => 'Thingie'})
-    @indirection = @thingie.indirects :first, :some => :options
+    expect(Puppet::Indirector::Indirection).to receive(:new).with(@thingie, :first, {:doc => 'some docs', :indirected_class => 'Thingie'})
+    @indirection = @thingie.indirects :first, :doc => 'some docs'
   end
 
   it "should extend the class to handle serialization" do

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -247,6 +247,21 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
           expect(subject).to include :result => :success
           graph_should_include 'pmtacceptance-mysql', nil => v('0.8.0')
         end
+
+        context 'with an already installed dependency' do
+          before { preinstall('pmtacceptance-stdlib', '2.6.0') }
+
+          def options
+            super.merge(:version => '0.7.0')
+          end
+
+          it 'installs given version without errors and does not change version of dependency' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-mysql', nil => v('0.7.0')
+            expect(subject[:error]).to be_nil
+            graph_should_include 'pmtacceptance-stdlib', v('2.6.0') => v('2.6.0')
+          end
+        end
       end
 
       context 'with a --version that cannot satisfy' do
@@ -258,6 +273,20 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
           expect(subject).to include :result => :failure
         end
 
+        it 'prints a detailed error containing the modules that would not be satisfied' do
+          graph = double(SemanticPuppet::Dependency::Graph, :modules => ['pmtacceptance-mysql'])
+          exception = SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph)
+          allow(exception).to receive(:respond_to?).and_return(true)
+          allow(exception).to receive(:unsatisfied).and_return('pmtacceptance-mysql')
+          allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(exception)
+
+          expect(subject[:error]).to include(:multiline)
+          expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+          expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
+          expect(subject[:error][:multiline]).to include("pmtacceptance-keystone, expects 'pmtacceptance-mysql': >=0.6.1 <1.0.0")
+          expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+        end
+
         context 'with --ignore-dependencies' do
           def options
             super.merge(:ignore_dependencies => true)
@@ -278,6 +307,43 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM =
             graph_should_include 'pmtacceptance-mysql', nil => v('2.1.0')
           end
         end
+
+        context 'with an already installed dependency' do
+          let(:graph) {
+            double(SemanticPuppet::Dependency::Graph,
+              :dependencies => {
+                'pmtacceptance-mysql' => {
+                  :version => '2.1.0'
+                }
+              },
+              :modules => ['pmtacceptance-mysql'],
+              :unsatisfied => 'pmtacceptance-stdlib'
+            )
+          }
+
+          let(:unsatisfiable_graph_exception) { SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph) }
+
+          before do
+            allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(unsatisfiable_graph_exception)
+            allow(unsatisfiable_graph_exception).to receive(:respond_to?).and_return(true)
+            allow(unsatisfiable_graph_exception).to receive(:unsatisfied).and_return(graph.unsatisfied)
+
+            preinstall('pmtacceptance-stdlib', '2.6.0')
+          end
+
+          def options
+            super.merge(:version => '2.1.0')
+          end
+
+          it 'fails to install and outputs a multiline error containing the versions, expectations and workaround' do
+            expect(subject).to include :result => :failure
+            expect(subject[:error]).to include(:multiline)
+            expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (v2.1.0)")
+            expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
+            expect(subject[:error][:multiline]).to include("pmtacceptance-stdlib, installed: 2.6.0, expected: >= 2.2.1")
+            expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+          end
+        end
       end
     end
 

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -86,4 +86,24 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
         and_yield(type, name, {:entry => entry})
     entry
   end
+
+  describe "Extracts tars with long and short pathnames" do
+    let (:sourcetar) { fixtures('module.tar.gz') }
+    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
+    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
+
+    it "unpacks a tar with a short path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
+    end
+
+    it "unpacks a tar with a long path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
+    end
+  end
 end

data/spec/unit/network/authconfig_spec.rb

@@ -6,9 +6,6 @@ describe Puppet::Network::DefaultAuthProvider do
   before :each do
     allow(Puppet::FileSystem).to receive(:stat).and_return(double('stat', :ctime => :now))
     allow(Time).to receive(:now).and_return(Time.now)
-
-    allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:exists?).and_return(true)
-    # FIXME @authprovider = Puppet::Network::DefaultAuthProvider.new("dummy")
   end
 
   describe "when initializing" do

data/spec/unit/network/format_support_spec.rb

@@ -67,8 +67,9 @@ describe Puppet::Network::FormatHandler do
       end
 
       it "should log a debug message" do
-        expect(Puppet).to receive(:debug).with("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)")
-        expect(Puppet).to receive(:debug).with("FormatTester supports formats: two one")
+        Puppet[:log_level] = 'debug'
+        expect(Puppet).to receive(:debug) { |&b| expect(b.call).to eq("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)") }
+        expect(Puppet).to receive(:debug) { |&b| expect(b.call).to eq("FormatTester supports formats: two one") }
         FormatTester.supported_formats
       end
     end

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -17,7 +17,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
   before do
     Puppet::IndirectorTesting.indirection.terminus_class = :memory
     Puppet::IndirectorTesting.indirection.terminus.clear
-    allow(handler).to receive(:warn_if_near_expiration)
   end
 
   describe "when converting a URI into a request" do
@@ -25,10 +24,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:env_loaders) { Puppet::Environments::Static.new(environment) }
     let(:params) { { :environment => "env" } }
 
-    before do
-      allow(handler).to receive(:handler).and_return("foo")
-    end
-
     around do |example|
       Puppet.override(:environments => env_loaders) do
         example.run
@@ -180,10 +175,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
     let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => environment) }
 
-    before do
-      allow(handler).to receive(:handler).and_return("foo")
-    end
-
     it "should include the environment in the query string of the URI" do
       expect(handler.class.request_to_uri(request)).to eq("#{master_url_prefix}/foo/with%20spaces?environment=myenv&foo=bar")
     end

data/spec/unit/network/http/api/master/v3/environments_spec.rb

@@ -7,13 +7,14 @@ require 'matchers/json'
 describe Puppet::Network::HTTP::API::Master::V3::Environments do
   include JSONMatchers
 
-  it "responds with all of the available environments" do
-    environment = Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests')
-    loader = Puppet::Environments::Static.new(environment)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
+  let(:environment) { Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests') }
+  let(:loader) { Puppet::Environments::Static.new(environment) }
+  let(:handler) { Puppet::Network::HTTP::API::Master::V3::Environments.new(loader) }
+  let(:request) { Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }) }
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+  it "responds with all of the available environments" do
+    handler.call(request, response)
 
     expect(response.code).to eq(200)
     expect(response.type).to eq("application/json")
@@ -33,29 +34,17 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for unlimited timeout" do
-    conf_stub = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(Float::INFINITY)
-    environment = Puppet::Node::Environment.create(:production, [])
-    env_loader = Puppet::Environments::Static.new(environment)
-    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
+    Puppet[:environment_timeout] = 'unlimited'
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+    handler.call(request, response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end
 
   it "the response conforms to the environments schema for integer timeout" do
-    conf_stub = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(1)
-    environment = Puppet::Node::Environment.create(:production, [])
-    env_loader = Puppet::Environments::Static.new(environment)
-    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
-
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+    Puppet[:environment_timeout] = 1
+
+    handler.call(request, response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end

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

@@ -102,11 +102,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/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

data/spec/unit/parser/compiler_spec.rb

@@ -240,20 +240,9 @@ describe Puppet::Parser::Compiler do
   end
 
   describe "when compiling" do
-    def compile_methods
-      [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated,
-        :finish, :store, :extract, :evaluate_relationships]
-    end
-
-    # Stub all of the main compile methods except the ones we're specifically interested in.
-    def compile_stub(*except)
-      (compile_methods - except).each { |m| allow(@compiler).to receive(m) }
-    end
-
     it "should set node parameters as variables in the top scope" do
       params = {"a" => "b", "c" => "d"}
       allow(@node).to receive(:parameters).and_return(params)
-      compile_stub(:set_node_parameters)
       @compiler.compile
       expect(@compiler.topscope['a']).to eq("b")
       expect(@compiler.topscope['c']).to eq("d")
@@ -262,13 +251,11 @@ describe Puppet::Parser::Compiler do
     it "should set node parameters that are of Symbol type as String variables in the top scope" do
       params = {"a" => :b}
       allow(@node).to receive(:parameters).and_return(params)
-      compile_stub(:set_node_parameters)
       @compiler.compile
       expect(@compiler.topscope['a']).to eq("b")
     end
 
     it "should set the node's environment as a string variable in top scope" do
-      compile_stub(:set_node_parameters)
       @node.merge({'wat' => 'this is how the sausage is made'})
       @compiler.compile
       expect(@compiler.topscope['environment']).to eq("testing")
@@ -276,7 +263,6 @@ describe Puppet::Parser::Compiler do
     end
 
     it "sets the environment based on node.environment instead of the parameters" do
-      compile_stub(:set_node_parameters)
       @node.parameters['environment'] = "Not actually #{@node.environment.name}"
 
       @compiler.compile
@@ -286,23 +272,21 @@ describe Puppet::Parser::Compiler do
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       allow(@node).to receive(:parameters).and_return(params)
-      compile_stub(:set_node_parameters)
       @compiler.compile
       expect(@compiler.catalog.client_version).to eq("2")
       expect(@compiler.catalog.server_version).to eq("3")
     end
 
     it "should evaluate the main class if it exists" do
-      compile_stub(:evaluate_main)
       main_class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
+      @compiler.topscope.source = main_class
+
       expect(main_class).to receive(:evaluate_code).with(be_a(Puppet::Parser::Resource))
-      expect(@compiler.topscope).to receive(:source=).with(main_class)
 
       @compiler.compile
     end
 
     it "should create a new, empty 'main' if no main class exists" do
-      compile_stub(:evaluate_main)
       @compiler.compile
       expect(@known_resource_types.find_hostclass("")).to be_instance_of(Puppet::Resource::Type)
     end
@@ -325,7 +309,7 @@ describe Puppet::Parser::Compiler do
       @compiler.add_collection(colls[0])
       @compiler.add_collection(colls[1])
 
-      compile_stub(:evaluate_generators)
+      allow(@compiler).to receive(:fail_on_unevaluated)
       @compiler.compile
     end
 

data/spec/unit/parser/resource_spec.rb

@@ -418,22 +418,27 @@ describe Puppet::Parser::Resource do
   end
 
   describe "when merging overrides" do
+    def resource_type(name)
+      double(name, :child_of? => false)
+    end
+
     before do
-      @source = "source1"
+      @source = resource_type("source1")
       @resource = mkresource :source => @source
       @override = mkresource :source => @source
     end
 
     it "should fail when the override was not created by a parent class" do
-      @override.source = "source2"
-      expect(@override.source).to receive(:child_of?).with("source1").and_return(false)
+      @override.source = resource_type("source2")
+      expect(@override.source).to receive(:child_of?).with(@source).and_return(false)
       expect { @resource.merge(@override) }.to raise_error(Puppet::ParseError)
     end
 
     it "should succeed when the override was created in the current scope" do
-      @resource.source = "source3"
+      @source3 = resource_type("source3")
+      @resource.source = @source3
       @override.source = @resource.source
-      expect(@override.source).not_to receive(:child_of?).with("source3")
+      expect(@override.source).not_to receive(:child_of?).with(@source3)
       params = {:a => :b, :c => :d}
       expect(@override).to receive(:parameters).and_return(params)
       expect(@resource).to receive(:override_parameter).with(:b)
@@ -442,9 +447,10 @@ describe Puppet::Parser::Resource do
     end
 
     it "should succeed when a parent class created the override" do
-      @resource.source = "source3"
-      @override.source = "source4"
-      expect(@override.source).to receive(:child_of?).with("source3").and_return(true)
+      @source3 = resource_type("source3")
+      @resource.source = @source3
+      @override.source = resource_type("source4")
+      expect(@override.source).to receive(:child_of?).with(@source3).and_return(true)
       params = {:a => :b, :c => :d}
       expect(@override).to receive(:parameters).and_return(params)
       expect(@resource).to receive(:override_parameter).with(:b)

data/spec/unit/parser/templatewrapper_spec.rb

@@ -57,9 +57,10 @@ describe Puppet::Parser::TemplateWrapper do
     expect(tw.all_tags).to eq(["tag1","tag2"])
   end
 
-  it "provides the tags defined in the current scope with #tags" do
-    expect(scope).to receive(:tags).and_return(["tag1", "tag2"])
-    expect(tw.tags).to eq(["tag1","tag2"])
+  it "raises not implemented error" do
+    expect {
+      tw.tags
+    }.to raise_error(NotImplementedError, /Call 'all_tags' instead/)
   end
 
   it "raises error on access to removed in-scope variables via method calls" do

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe Puppet::Pops::Evaluator::DeferredResolver do
+  include PuppetSpec::Compiler
+
+  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+  let(:facts) { Puppet::Node::Facts.new('node.example.com') }
+
+  it 'resolves deferred values in a catalog' do
+    catalog = compile_to_catalog(<<~END)
+      notify { "deferred":
+        message => Deferred("join", [[1,2,3], ":"])
+      }
+    END
+    described_class.resolve_and_replace(facts, catalog)
+
+    expect(catalog.resource(:notify, 'deferred')[:message]).to eq('1:2:3')
+  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))