puppet 5.5.2-universal-darwin → 5.5.3-universal-darwin

data/spec/unit/provider/package/rpm_spec.rb

@@ -41,8 +41,12 @@ describe provider_class do
     Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
     provider_class.stubs(:which).with("rpm").returns("/bin/rpm")
     provider_class.instance_variable_set("@current_version", nil)
-    Puppet::Type::Package::ProviderRpm.expects(:execute).with(["/bin/rpm", "--version"]).returns(rpm_version).at_most_once
-    Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], execute_options).returns(rpm_version).at_most_once
+    Puppet::Type::Package::ProviderRpm.expects(:execute)
+      .with(["/bin/rpm", "--version"])
+      .returns(rpm_version).at_most_once
+    Puppet::Util::Execution.expects(:execute)
+      .with(["/bin/rpm", "--version"], execute_options)
+      .returns(Puppet::Util::Execution::ProcessOutput.new(rpm_version, 0)).at_most_once
   end
 
   describe 'provider features' do
@@ -203,7 +207,9 @@ describe provider_class do
   describe "#latest" do
     it "retrieves version string after querying rpm for version from source file" do
       resource.expects(:[]).with(:source).returns('source-string')
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"]).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+      Puppet::Util::Execution.expects(:execute)
+        .with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"])
+        .returns(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       expect(provider.latest).to eq("1.2.3.4-5.el4")
     end
 
@@ -227,33 +233,43 @@ describe provider_class do
 
     describe "on a modern RPM" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+        Puppet::Util::Execution.expects(:execute)
+          .with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .returns(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       end
 
       let(:rpm_version) { "RPM version 4.10.0\n" }
 
       it "includes the architecture in the package name" do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options).returns('').at_most_once
+        Puppet::Util::Execution.expects(:execute)
+          .with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options)
+          .returns(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most_once
         provider.uninstall
       end
     end
 
     describe "on an ancient RPM" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "myresource", '', '', '--qf', "'#{nevra_format}'"], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+        Puppet::Util::Execution.expects(:execute)
+          .with(["/bin/rpm", "-q", "myresource", '', '', '--qf', "'#{nevra_format}'"], execute_options)
+          .returns(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       end
 
       let(:rpm_version) { "RPM version 3.0.6\n" }
 
       it "excludes the architecture from the package name" do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4'], execute_options).returns('').at_most_once
+        Puppet::Util::Execution.expects(:execute)
+          .with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4'], execute_options)
+          .returns(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most_once
         provider.uninstall
       end
     end
 
     describe "when uninstalled with options" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+        Puppet::Util::Execution.expects(:execute)
+          .with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .returns(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       end
 
       let(:resource) do
@@ -275,7 +291,9 @@ describe provider_class do
   describe "parsing" do
     def parser_test(rpm_output_string, gold_hash, number_of_debug_logs = 0)
       Puppet.expects(:debug).times(number_of_debug_logs)
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"], execute_options).returns(rpm_output_string)
+      Puppet::Util::Execution.expects(:execute)
+        .with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"], execute_options)
+        .returns(Puppet::Util::Execution::ProcessOutput.new(rpm_output_string, 0))
       expect(provider.query).to eq(gold_hash)
     end
 
@@ -336,7 +354,9 @@ describe provider_class do
       provider.resource[:allow_virtual] = true
       expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"]
       Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not installed")
-      Puppet::Util::Execution.expects(:execute).with(expected_args + ["--whatprovides"], execute_options).returns "myresource 0 1.2.3.4 5.el4 noarch\n"
+      Puppet::Util::Execution.expects(:execute)
+        .with(expected_args + ["--whatprovides"], execute_options)
+        .returns(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       expect(provider.query).to eq({
         :name     => "myresource",
         :epoch    => "0",

data/spec/unit/provider/package/urpmi_spec.rb

@@ -7,7 +7,9 @@ describe Puppet::Type.type(:package).provider(:urpmi) do
     %w[rpm urpmi urpme urpmq].each do |executable|
       Puppet::Util.stubs(:which).with(executable).returns(executable)
     end
-    Puppet::Util::Execution.stubs(:execute).with(['rpm', '--version'], anything).returns 'RPM version 4.9.1.3'
+    Puppet::Util::Execution.stubs(:execute)
+      .with(['rpm', '--version'], anything)
+      .returns(Puppet::Util::Execution::ProcessOutput.new('RPM version 4.9.1.3', 0))
   end
 
   let(:resource) do
@@ -53,13 +55,17 @@ describe Puppet::Type.type(:package).provider(:urpmi) do
     let(:urpmq_output) { 'foopkg : Lorem ipsum dolor sit amet, consectetur adipisicing elit ( 7.8.9-1.mga2 )' }
 
     it "uses urpmq to determine the latest package" do
-      Puppet::Util::Execution.expects(:execute).with(['urpmq', '-S', 'foopkg'], anything).returns urpmq_output
+      Puppet::Util::Execution.expects(:execute)
+        .with(['urpmq', '-S', 'foopkg'], anything)
+        .returns(Puppet::Util::Execution::ProcessOutput.new(urpmq_output, 0))
       expect(subject.latest).to eq('7.8.9-1.mga2')
     end
 
     it "falls back to the current version" do
       resource[:ensure] = '5.4.3'
-      Puppet::Util::Execution.expects(:execute).with(['urpmq', '-S', 'foopkg'], anything).returns ''
+      Puppet::Util::Execution.expects(:execute)
+        .with(['urpmq', '-S', 'foopkg'], anything)
+        .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
       expect(subject.latest).to eq('5.4.3')
     end
   end

data/spec/unit/provider/selmodule_spec.rb

@@ -30,6 +30,12 @@ describe provider_class do
       expect(@provider.exists?).to be_nil
     end
 
+    it "should return nil if module with same suffix is loaded" do
+      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
+      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("bar\t1.2.3\nmyfoo\t1.0.0\n")
+      expect(@provider.exists?).to be_nil
+    end
+
     it "should return nil if no modules are loaded" do
       @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
       @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("")

data/spec/unit/provider/service/openrc_spec.rb

@@ -74,7 +74,7 @@ describe Puppet::Type.type(:service).provider(:openrc) do
         Puppet::Util::Execution.expects(:execute).with(
           includes('/bin/rc-status'),
           has_entry(:custom_environment, {:RC_SVCNAME => nil})
-        ).returns ''
+        ).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
         subject.enabled?
       end
     end

data/spec/unit/resource/status_spec.rb

@@ -165,6 +165,7 @@ describe Puppet::Resource::Status do
       s.out_of_sync = true
       s.skipped = false
       s.provider_used = 'provider_used_class_name'
+      s.failed_to_restart = false
       s
     end
 
@@ -187,6 +188,7 @@ describe Puppet::Resource::Status do
       expect(tripped.changed).to eq(status.changed)
       expect(tripped.out_of_sync).to eq(status.out_of_sync)
       expect(tripped.skipped).to eq(status.skipped)
+      expect(tripped.failed_to_restart).to eq(status.failed_to_restart)
 
       expect(tripped.change_count).to eq(status.change_count)
       expect(tripped.out_of_sync_count).to eq(status.out_of_sync_count)

data/spec/unit/resource/type_collection_spec.rb

@@ -320,7 +320,10 @@ describe Puppet::Resource::TypeCollection do
       let(:environment) { Puppet::Node::Environment.create(:testing, [], '', '/my/foo') }
 
       it "should use the output of the environment's config_version setting if one is provided" do
-        Puppet::Util::Execution.expects(:execute).with(["/my/foo"]).returns "output\n"
+        Puppet::Util::Execution.expects(:execute)
+          .with(["/my/foo"])
+          .returns Puppet::Util::Execution::ProcessOutput.new("output\n", 0)
+        expect(@code.version).to be_instance_of(String)
         expect(@code.version).to eq("output")
       end
 

data/spec/unit/ssl/certificate_request_spec.rb

@@ -177,6 +177,17 @@ describe Puppet::SSL::CertificateRequest do
       end
     end
 
+    context "with DNS and IP SAN specified" do
+      before :each do
+        Puppet[:dns_alt_names] = ""
+      end
+
+      it "should return the subjectAltName values" do
+        request.generate(key, :dns_alt_names => 'DNS:foo, bar, IP:172.16.254.1')
+        expect(request.subject_alt_names).to match_array(["DNS:bar", "DNS:foo", "DNS:myname", "IP Address:172.16.254.1"])
+      end
+    end
+
     context "with custom CSR attributes" do
 
       it "adds attributes with single values" do

data/spec/unit/transaction/event_manager_spec.rb

@@ -287,6 +287,18 @@ describe Puppet::Transaction::EventManager do
         expect(@transaction.resource_status(@resource)).to be_failed_to_restart
       end
 
+      it "should set the 'failed' state on the resource status" do
+        @manager.process_events(@resource)
+        expect(@transaction.resource_status(@resource)).to be_failed
+      end
+
+      it "should record a failed event on the resource status" do
+        @manager.process_events(@resource)
+
+        expect(@transaction.resource_status(@resource).events.length).to eq(1)
+        expect(@transaction.resource_status(@resource).events[0].status).to eq('failure')
+      end
+
       it "should not queue a 'restarted' event" do
         @manager.expects(:queue_events).never
         @manager.process_events(@resource)

data/spec/unit/util/diff_spec.rb

@@ -4,12 +4,16 @@ require 'puppet/util/diff'
 require 'puppet/util/execution'
 
 describe Puppet::Util::Diff do
+  let(:baz_output) { Puppet::Util::Execution::ProcessOutput.new('baz', 0) }
+
   describe ".diff" do
     it "should execute the diff command with arguments" do
       Puppet[:diff] = 'foo'
       Puppet[:diff_args] = 'bar'
 
-      Puppet::Util::Execution.expects(:execute).with(['foo', 'bar', 'a', 'b'], {:failonfail => false, :combine => false}).returns('baz')
+      Puppet::Util::Execution.expects(:execute)
+        .with(['foo', 'bar', 'a', 'b'], {:failonfail => false, :combine => false})
+        .returns(baz_output)
       expect(subject.diff('a', 'b')).to eq('baz')
     end
 
@@ -17,7 +21,9 @@ describe Puppet::Util::Diff do
       Puppet[:diff] = 'foo'
       Puppet[:diff_args] = 'bar qux'
 
-      Puppet::Util::Execution.expects(:execute).with(['foo', 'bar', 'qux', 'a', 'b'], anything).returns('baz')
+      Puppet::Util::Execution.expects(:execute)
+        .with(['foo', 'bar', 'qux', 'a', 'b'], anything)
+        .returns(baz_output)
       expect(subject.diff('a', 'b')).to eq('baz')
     end
 
@@ -25,7 +31,9 @@ describe Puppet::Util::Diff do
       Puppet[:diff] = 'foo'
       Puppet[:diff_args] = ''
 
-      Puppet::Util::Execution.expects(:execute).with(['foo', 'a', 'b'], {:failonfail => false, :combine => false}).returns('baz')
+      Puppet::Util::Execution.expects(:execute)
+        .with(['foo', 'a', 'b'], {:failonfail => false, :combine => false})
+        .returns(baz_output)
       expect(subject.diff('a', 'b')).to eq('baz')
     end
 

data/spec/unit/util/execution_spec.rb

@@ -821,7 +821,8 @@ describe Puppet::Util::Execution do
 
   describe "execfail" do
     it "returns the executed command output" do
-      Puppet::Util::Execution.stubs(:execute).returns("process output")
+      Puppet::Util::Execution.stubs(:execute)
+        .returns(Puppet::Util::Execution::ProcessOutput.new("process output", 0))
       expect(Puppet::Util::Execution.execfail('echo hello', Puppet::Error)).to eq('process output')
     end
 

data/spec/unit/util/filetype_spec.rb

@@ -108,14 +108,18 @@ describe Puppet::Util::FileType do
 
     describe "#read" do
       it "should run crontab -l as the target user" do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).returns crontab
+        Puppet::Util::Execution.expects(:execute)
+          .with(['crontab', '-l'], user_options)
+          .returns(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
         expect(cron.read).to eq(crontab)
       end
 
       it "should not switch user if current user is the target user" do
         Puppet::Util.expects(:uid).with(uid).returns 9000
         Puppet::Util::SUIDManager.expects(:uid).returns 9000
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], options).returns crontab
+        Puppet::Util::Execution
+          .expects(:execute).with(['crontab', '-l'], options)
+          .returns(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
         expect(cron.read).to eq(crontab)
       end
 

data/spec/unit/util/log/destinations_spec.rb

@@ -47,24 +47,40 @@ describe Puppet::Util::Log.desttypes[:file] do
     end
 
     describe "on POSIX systems", :if => Puppet.features.posix? do
-      let (:abspath) { '/tmp/log' }
-      let (:relpath) { 'log' }
+      describe "with a normal file" do
+        let (:abspath) { '/tmp/log' }
+        let (:relpath) { 'log' }
 
-      it_behaves_like "file destination"
+        it_behaves_like "file destination"
+
+        it "logs an error if it can't chown the file owner & group" do
+          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).raises(Errno::EPERM)
+          Puppet.features.expects(:root?).returns(true)
+          Puppet.expects(:err).with("Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{abspath}")
 
-      it "logs an error if it can't chown the file owner & group" do
-        FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).raises(Errno::EPERM)
-        Puppet.features.expects(:root?).returns(true)
-        Puppet.expects(:err).with("Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{abspath}")
+          @class.new(abspath)
+        end
 
-        @class.new(abspath)
+        it "doesn't attempt to chown when running as non-root" do
+          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
+          Puppet.features.expects(:root?).returns(false)
+
+          @class.new(abspath)
+        end
       end
 
-      it "doesn't attempt to chown when running as non-root" do
-        FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
-        Puppet.features.expects(:root?).returns(false)
+      describe "with a JSON file" do
+        let (:abspath) { '/tmp/log.json' }
+        let (:relpath) { 'log.json' }
+
+        it_behaves_like "file destination"
 
-        @class.new(abspath)
+        it "should log messages as JSON" do
+          msg = Puppet::Util::Log.new(:level => :info, :message => "don't panic")
+          dest = @class.new(abspath)
+          dest.handle(msg)
+          expect(JSON.parse(File.read(abspath) + ']')).to include(a_hash_including({"message" => "don't panic"}))
+        end
       end
     end
 

data/spec/unit/util/plist_spec.rb

@@ -92,8 +92,10 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
       subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(invalid_xml_plist)
       Puppet.expects(:debug).with(regexp_matches(/^Failed with CFFormatError/))
       Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
-                                                     {:failonfail => true, :combine => true}).returns(valid_xml_plist)
+      Puppet::Util::Execution.expects(:execute)
+        .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
+              {:failonfail => true, :combine => true})
+        .returns(Puppet::Util::Execution::ProcessOutput.new(valid_xml_plist, 0))
       expect(subject.read_plist_file(plist_path)).to eq(valid_xml_plist_hash)
     end
     it "returns nil when direct parsing and plutil conversion both fail" do
@@ -101,8 +103,10 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
       subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(non_plist_data)
       Puppet.expects(:debug).with(regexp_matches(/^Failed with (CFFormatError|NoMethodError)/))
       Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
-                                                     {:failonfail => true, :combine => true}).raises(Puppet::ExecutionFailure, 'boom')
+      Puppet::Util::Execution.expects(:execute)
+        .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
+              {:failonfail => true, :combine => true})
+        .raises(Puppet::ExecutionFailure, 'boom')
       expect(subject.read_plist_file(plist_path)).to eq(nil)
     end
     it "returns nil when file is a non-plist binary blob" do
@@ -110,8 +114,10 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
       subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(binary_data)
       Puppet.expects(:debug).with(regexp_matches(/^Failed with (CFFormatError|ArgumentError)/))
       Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
-                                                     {:failonfail => true, :combine => true}).raises(Puppet::ExecutionFailure, 'boom')
+      Puppet::Util::Execution.expects(:execute)
+        .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
+              {:failonfail => true, :combine => true})
+        .raises(Puppet::ExecutionFailure, 'boom')
       expect(subject.read_plist_file(plist_path)).to eq(nil)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet
 version: !ruby/object:Gem::Version
-  version: 5.5.2
+  version: 5.5.3
 platform: universal-darwin
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-29 00:00:00.000000000 Z
+date: 2018-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facter