puppet 6.17.0-x64-mingw32 → 6.18.0-x64-mingw32

data/spec/unit/application/facts_spec.rb

@@ -2,21 +2,50 @@ require 'spec_helper'
 require 'puppet/application/facts'
 
 describe Puppet::Application::Facts do
+  let(:app) { Puppet::Application[:facts] }
+  let(:values) { {"filesystems" => "apfs,autofs,devfs"} }
+
   before :each do
-    allow(subject.command_line).to receive(:subcommand_name).and_return('facts')
+    Puppet::Node::Facts.indirection.terminus_class = :memory
   end
 
-  it "should return facts if a key is given to find" do
-    Puppet::Node::Facts.indirection.reset_terminus_class
-    expect(Puppet::Node::Facts.indirection).to receive(:find).and_return(Puppet::Node::Facts.new('whatever', {}))
-    allow(subject.command_line).to receive(:args).and_return(%w{find whatever --render-as yaml})
+  it "returns facts for a given node" do
+    facts = Puppet::Node::Facts.new('whatever', values)
+    Puppet::Node::Facts.indirection.save(facts)
+
+    app.command_line.args = %w{find whatever --render-as yaml}
+
+    # due to PUP-10105 we emit the class tag when we shouldn't
+    expected = Regexp.new(<<~END)
+      --- !ruby/object:Puppet::Node::Facts
+      name: whatever
+      values:
+        filesystems: apfs,autofs,devfs
+    END
 
     expect {
-      expect {
-        subject.run
-      }.to exit_with(0)
-    }.to have_printed(/object:Puppet::Node::Facts/)
+      app.run
+    }.to exit_with(0)
+     .and output(expected).to_stdout
+  end
 
-    expect(@logs).to be_empty
+  it "returns facts for the current node when the name is omitted" do
+    facts = Puppet::Node::Facts.new(Puppet[:certname], values)
+    Puppet::Node::Facts.indirection.save(facts)
+
+    app.command_line.args = %w{find --render-as yaml}
+
+    # due to PUP-10105 we emit the class tag when we shouldn't
+    expected = Regexp.new(<<~END)
+      --- !ruby/object:Puppet::Node::Facts
+      name: #{Puppet[:certname]}
+      values:
+        filesystems: apfs,autofs,devfs
+    END
+
+    expect {
+      app.run
+    }.to exit_with(0)
+     .and output(expected).to_stdout
   end
 end

data/spec/unit/application/man_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:man, :current] do
+  let(:pager) { '/path/to/our/pager' }
+
+  around do |example|
+    Puppet::Util.withenv('MANPAGER' => pager) do
+      example.run
+    end
+  end
+
+  it 'is deprecated' do
+    expect(subject).to be_deprecated
+  end
+
+  it 'has a man action' do
+    expect(subject).to be_action(:man)
+  end
+
+  it 'accepts a call with no arguments' do
+    expect { subject.man }.to output(/USAGE: puppet man <action>/).to_stdout
+  end
+
+  it 'raises an ArgumentError when given too many arguments' do
+    expect {
+      subject.man(:man, 'agent', 'extra')
+    }.to raise_error(ArgumentError)
+     .and output(/USAGE: puppet man <action>/).to_stdout
+  end
+
+  it "exits with 0 when generating man documentation for each available application" do
+    # turn off deprecation warning
+    Puppet[:disable_warnings] = ['deprecations']
+
+    allow(Puppet::Util).to receive(:which).with('ronn').and_return(nil)
+    allow(Puppet::Util).to receive(:which).with(pager).and_return(pager)
+
+    Puppet::Application.available_application_names.each do |name|
+      next if %w{man face_base indirection_base}.include? name
+
+      app = Puppet::Application[:man]
+      app.command_line.args << 'man' << name
+
+      expect {
+        allow(IO).to receive(:popen).with(pager, 'w:UTF-8').and_yield($stdout)
+        app.run
+      }.to exit_with(0)
+       .and output(/puppet-#{name}/m).to_stdout
+    end
+  end
+end

data/spec/unit/application/resource_spec.rb

@@ -51,7 +51,9 @@ describe Puppet::Application::Resource do
       # provider is a parameter that should always be available
       @resource_app.extra_params = [ :provider ]
 
-      expect { @resource_app.main }.to have_printed(/provider\s+=>/)
+      expect {
+        @resource_app.main
+      }.to output(/provider\s+=>/).to_stdout
     end
   end
 

data/spec/unit/application/ssl_spec.rb

@@ -38,7 +38,7 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
   def expects_command_to_pass(expected_output = nil)
     expect {
       ssl.run_command
-    }.to have_printed(expected_output)
+    }.to output(expected_output).to_stdout
   end
 
   def expects_command_to_fail(message)
@@ -46,7 +46,7 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
       expect {
         ssl.run_command
       }.to raise_error(Puppet::Error, message)
-    }.to have_printed(/.*/) # ignore output
+    }.to output(/.*/).to_stdout
   end
 
   shared_examples_for 'an ssl action' do
@@ -266,6 +266,19 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
       FileUtils.cp(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'encrypted-key.pem'), Puppet[:hostprivkey])
       FileUtils.cp(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'signed.pem'), Puppet[:hostcert])
 
+      # To verify the client cert we need the root and intermediate certs and crls.
+      # We don't need to do this with `ssl-client` cert above, because it is issued
+      # directly from the generated TestCa above.
+      File.open(Puppet[:localcacert], 'w') do |f|
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'ca.pem')))
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'intermediate.pem')))
+      end
+
+      File.open(Puppet[:hostcrl], 'w') do |f|
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'crl.pem')))
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'intermediate-crl.pem')))
+      end
+
       Puppet[:passfile] = file_containing('passfile', '74695716c8b6')
 
       expects_command_to_pass(%r{Verified client certificate 'CN=signed' fingerprint})

data/spec/unit/configurer/downloader_spec.rb

@@ -228,5 +228,15 @@ describe Puppet::Configurer::Downloader do
 
       expect { @dler.evaluate }.not_to raise_error
     end
+
+    it "raises an exception if catalog application fails" do
+      Puppet[:ignore_plugin_errors] = false
+
+      expect(@dler.file).to receive(:retrieve).and_raise(Puppet::Error, "testing")
+
+      expect {
+        @dler.evaluate
+      }.to raise_error(Puppet::Error, /testing/)
+    end
   end
 end

data/spec/unit/configurer_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'puppet/configurer'
-require 'webmock/rspec'
 
 describe Puppet::Configurer do
   before do
@@ -85,6 +84,26 @@ describe Puppet::Configurer do
       expect(configurer.run).to eq(0)
     end
 
+    it "fails the run if pluginsync fails when usecacheonfailure is false" do
+      Puppet[:ignore_plugin_errors] = false
+
+      # --test implies these, set them so we don't fall back to a cached catalog
+      Puppet[:use_cached_catalog] = false
+      Puppet[:usecacheonfailure] = false
+
+      body = "{\"message\":\"Not Found: Could not find environment 'fasdfad'\",\"issue_kind\":\"RUNTIME_ERROR\"}"
+      stub_request(:get, %r{/puppet/v3/file_metadatas/pluginfacts}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+      stub_request(:get, %r{/puppet/v3/file_metadata/pluginfacts}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+
+      configurer.run(pluginsync: true)
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: %r{Failed to apply catalog: Failed to retrieve pluginfacts: Could not retrieve information from environment production source\(s\) puppet:///pluginfacts}))
+    end
+
     it "applies a cached catalog when it can't connect to the master" do
       error = Errno::ECONNREFUSED.new('Connection refused - connect(2)')
 
@@ -96,7 +115,8 @@ describe Puppet::Configurer do
     end
 
     it "should initialize a transaction report if one is not provided" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
+      # host and settings catalogs each create a report...
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report).twice
 
       configurer.run
     end
@@ -192,22 +212,21 @@ describe Puppet::Configurer do
     end
 
     it "should remove the report as a log destination when the run is finished" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
-      configurer.run
+      configurer.run(report: report)
 
       expect(Puppet::Util::Log.destinations).not_to include(report)
     end
 
-    it "should return the report exit_status as the result of the run" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-      expect(report).to receive(:exit_status).and_return(1234)
+    it "should return an exit status of 2 due to the notify resource 'changing'" do
+      cat = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
+      cat.add_resource(Puppet::Type.type(:notify).new(:name => 'something changed'))
 
-      expect(configurer.run).to eq(1234)
+      expect(configurer.run(catalog: cat, report: report)).to eq(2)
     end
 
     it "should return nil if catalog application fails" do
-      expect_any_instance_of(Puppet::Resource::Catalog).to receive(:apply).and_raise(Puppet::Error, 'One or more resource dependency cycles detected in graph')
+      expect(catalog).to receive(:apply).and_raise(Puppet::Error, 'One or more resource dependency cycles detected in graph')
+
       expect(configurer.run(catalog: catalog, report: report)).to be_nil
     end
 
@@ -222,34 +241,28 @@ describe Puppet::Configurer do
     end
 
     it "should include the pre-run command failure in the report" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:prerun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
       expect(report.logs.find { |x| x.message =~ /Could not run command from prerun_command/ }).to be
     end
 
     it "should send the transaction report even if the post-run command fails" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
       expect(configurer).to receive(:send_report).with(report)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it "should include the post-run command failure in the report" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect(report).to receive(:<<) { |log, _| expect(log.message).to match(/Could not run command from postrun_command/) }.at_least(:once)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it "should execute post-run command even if the pre-run command fails" do
@@ -262,34 +275,28 @@ describe Puppet::Configurer do
     end
 
     it "should finalize the report" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       expect(report).to receive(:finalize_report)
-      configurer.run
+      configurer.run(report: report)
     end
 
     it "should not apply the catalog if the pre-run command fails" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:prerun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect_any_instance_of(Puppet::Resource::Catalog).not_to receive(:apply)
       expect(configurer).to receive(:send_report)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it "should apply the catalog, send the report, and return nil if the post-run command fails" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect_any_instance_of(Puppet::Resource::Catalog).to receive(:apply)
       expect(configurer).to receive(:send_report)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it 'includes total time metrics in the report after successfully applying the catalog' do
@@ -546,6 +553,15 @@ describe Puppet::Configurer do
     end
   end
 
+  def expects_pluginsync
+    metadata = "[{\"path\":\"/etc/puppetlabs/code\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":0,\"group\":0,\"mode\":420,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-07-10 14:00:00 -0700\"},\"type\":\"directory\",\"destination\":null}]"
+    stub_request(:get, %r{/puppet/v3/file_metadatas/(plugins|locales)}).to_return(status: 200, body: metadata, headers: {'Content-Type' => 'application/json'})
+
+    # response retains owner/group/mode due to source_permissions => use
+    facts_metadata = "[{\"path\":\"/etc/puppetlabs/code\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":500,\"group\":500,\"mode\":493,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-07-10 14:00:00 -0700\"},\"type\":\"directory\",\"destination\":null}]"
+    stub_request(:get, %r{/puppet/v3/file_metadatas/pluginfacts}).to_return(status: 200, body: facts_metadata, headers: {'Content-Type' => 'application/json'})
+  end
+
   def expects_new_catalog_only(catalog)
     expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(catalog)
     expect(Puppet::Resource::Catalog.indirection).not_to receive(:find).with(anything, hash_including(ignore_terminus: true))
@@ -562,6 +578,7 @@ describe Puppet::Configurer do
   end
 
   def expects_fallback_to_new_catalog(catalog)
+    expects_pluginsync
     expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(nil)
     expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(catalog)
   end
@@ -598,7 +615,6 @@ describe Puppet::Configurer do
       it "should make a node request and pluginsync when a cached catalog cannot be retrieved" do
         expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
         expects_fallback_to_new_catalog(catalog)
-        expect(configurer).to receive(:download_plugins)
 
         configurer.run
       end
@@ -636,6 +652,7 @@ describe Puppet::Configurer do
       it "should not attempt to retrieve a cached catalog again if the first attempt failed" do
         expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
         expects_neither_new_or_cached_catalog
+        expects_pluginsync
 
         # after failing to use a cached catalog, we'll need to pluginsync before getting
         # a new catalog, which also fails.
@@ -656,8 +673,7 @@ describe Puppet::Configurer do
       end
 
       it "applies the catalog passed as options when the catalog cache terminus is not set" do
-        stub_request(:get, %r{/puppet/v3/file_metadatas?/plugins}).to_return(:status => 404)
-        stub_request(:get, %r{/puppet/v3/file_metadatas?/pluginfacts}).to_return(:status => 404)
+        expects_pluginsync
 
         catalog.add_resource(Puppet::Resource.new('notify', 'from apply'))
         configurer.run(catalog: catalog.to_ral)

data/spec/unit/confine_spec.rb

@@ -54,10 +54,11 @@ describe Puppet::Confine do
     end
 
     it "should log failing confines with the label and message" do
+      Puppet[:log_level] = 'debug'
       allow(@confine).to receive(:pass?).and_return(false)
       expect(@confine).to receive(:message).and_return("My message")
       expect(@confine).to receive(:label).and_return("Mylabel")
-      expect(Puppet).to receive(:debug).with("Mylabel: My message")
+      expect(Puppet).to receive(:debug) { |&b| expect(b.call).to eq("Mylabel: My message") }
       @confine.valid?
     end
   end

data/spec/unit/face/config_spec.rb

@@ -234,7 +234,9 @@ trace = true
       allow(Puppet::Settings::IniFile::Manipulator).to receive(:new).and_return(manipulator)
 
       expect(manipulator).to receive(:delete).with('main', 'setting').and_return('    setting=value')
-      expect { subject.delete('setting', {:section => 'main'}) }.to have_printed("Deleted setting from 'main': 'setting=value'")
+      expect {
+        subject.delete('setting', {:section => 'main'})
+      }.to output("Deleted setting from 'main': 'setting=value'\n").to_stdout
     end
 
     it 'prints a warning when a setting is not found to delete' do

data/spec/unit/file_serving/mount/locales_spec.rb

@@ -52,13 +52,13 @@ describe Puppet::FileServing::Mount::Locales do
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
-    it "should return nil if no modules can be found that have locales and modulepath is invalid" do
+    it "should return the default search module path if no modules can be found that have locales and modulepath is invalid" do
       mod = double('module')
       allow(mod).to receive(:locales?).and_return(false)
 
       allow(@environment).to receive(:modules).and_return([])
       allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to be_nil
+      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
     end
 
     it "should return the locale paths for each module that has locales" do

data/spec/unit/file_serving/mount/pluginfacts_spec.rb

@@ -52,13 +52,13 @@ describe Puppet::FileServing::Mount::PluginFacts do
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
-    it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
+    it "should return the default search module path if no modules can be found that have plugins and modulepath is invalid" do
       mod = double('module')
       allow(mod).to receive(:pluginfacts?).and_return(false)
 
       allow(@environment).to receive(:modules).and_return([])
       allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to be_nil
+      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
     end
 
     it "should return the plugin paths for each module that has plugins" do

data/spec/unit/file_serving/mount/plugins_spec.rb

@@ -52,13 +52,13 @@ describe Puppet::FileServing::Mount::Plugins do
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
-    it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
+    it "should return the default search module path if no modules can be found that have plugins and modulepath is invalid" do
       mod = double('module')
       allow(mod).to receive(:plugins?).and_return(false)
 
       allow(@environment).to receive(:modules).and_return([])
       allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to be_nil
+      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
     end
 
     it "should return the plugin paths for each module that has plugins" do