puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/spec/unit/type/component_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 component = Puppet::Type.type(:component)

data/spec/unit/type/exec_spec.rb

@@ -1,10 +1,11 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-RSpec.describe Puppet::Type.type(:exec) do
+describe Puppet::Type.type(:exec) do
   include PuppetSpec::Files
 
   def exec_tester(command, exitstatus = 0, rest = {})
-    allow(Puppet.features).to receive(:root?).and_return(true)
+    Puppet.features.stubs(:root?).returns(true)
 
     output = rest.delete(:output) || ''
 
@@ -20,44 +21,16 @@ RSpec.describe Puppet::Type.type(:exec) do
     }.merge(rest)
 
     exec = Puppet::Type.type(:exec).new(type_args)
-    expect(Puppet::Util::Execution).to receive(:execute) do |cmd, options|
-      expect(cmd).to eq(command)
-      expect(options[:override_locale]).to eq(false)
-      expect(options).to have_key(:custom_environment)
 
-      output
-    end.exactly(tries).times
+    Puppet::Util::Execution.expects(:execute).times(tries).with() do |*args|
+      args[0] == command &&
+      args[1][:override_locale] == false &&
+      args[1].has_key?(:custom_environment)
+    end.returns(output)
 
     return exec
   end
 
-  def exec_stub(options = {})
-    command = options.delete(:command) || @command
-    #unless_val = options.delete(:unless) || :true
-    type_args = {
-      :name   => command,
-      #:unless => unless_val,
-    }.merge(options)
-
-    # Chicken, meet egg:
-    # Provider methods have to be stubbed before resource init or checks fail
-    # We have to set 'unless' in resource init or it can not be marked sensitive correctly.
-    # So: we create a dummy ahead of time and use 'any_instance' to stub out provider methods.
-    dummy = Puppet::Type.type(:exec).new(:name => @command)
-    allow_any_instance_of(dummy.provider.class).to receive(:validatecmd)
-    allow_any_instance_of(dummy.provider.class).to receive(:checkexe).and_return(true)
-    pass_status = double('status', :exitstatus => 0, :split => ["pass output"])
-    fail_status = double('status', :exitstatus => 1, :split => ["fail output"])
-    allow(Puppet::Util::Execution).to receive(:execute).with(:true, anything).and_return(pass_status)
-    allow(Puppet::Util::Execution).to receive(:execute).with(:false, anything).and_return(fail_status)
-
-    test = Puppet::Type.type(:exec).new(type_args)
-
-    Puppet::Util::Log.level = :debug
-
-    return test
-  end
-
   before do
     @command = make_absolute('/bin/true whatever')
     @executable = make_absolute('/bin/true')
@@ -67,7 +40,7 @@ RSpec.describe Puppet::Type.type(:exec) do
   describe "when not stubbing the provider" do
     before do
       path = tmpdir('path')
-      ext = Puppet.features.microsoft_windows? ? '.exe' : ''
+      ext = Puppet::Util::Platform.windows? ? '.exe' : ''
       true_cmd = File.join(path, "true#{ext}")
       false_cmd = File.join(path, "false#{ext}")
 
@@ -150,13 +123,16 @@ RSpec.describe Puppet::Type.type(:exec) do
         end
       end
 
-      it "should redact the sensitive command on failure" do
+      it "should redact the command on failure" do
         output = "output1\noutput2\n"
         expect { exec_tester('false', 1, :output => output, :logoutput => :on_failure, :sensitive_parameters => [:command]).refresh }.
             to raise_error(Puppet::Error, /^\[command redacted\] returned 1 instead of/)
 
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: '[output redacted]'))
-        expect(@logs).to_not include(an_object_having_attributes(message: /output1|output2/))
+        output.split("\n").each do |line|
+          log = @logs.shift
+          expect(log.level).to eq(:err)
+          expect(log.message).to eq(line)
+        end
       end
 
       it "should log the output on failure when returns is specified as an array" do
@@ -174,7 +150,7 @@ RSpec.describe Puppet::Type.type(:exec) do
         end
       end
 
-      it "should redact the sensitive command on failure when returns is specified as an array" do
+      it "should redact the command on failure when returns is specified as an array" do
         output = "output1\noutput2\n"
 
         expect {
@@ -182,8 +158,11 @@ RSpec.describe Puppet::Type.type(:exec) do
                       :logoutput => :on_failure, :sensitive_parameters => [:command]).refresh
         }.to raise_error(Puppet::Error, /^\[command redacted\] returned 1 instead of/)
 
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: '[output redacted]'))
-        expect(@logs).to_not include(an_object_having_attributes(message: /output1|output2/))
+        output.split("\n").each do |line|
+          log = @logs.shift
+          expect(log.level).to eq(:err)
+          expect(log.message).to eq(line)
+        end
       end
 
       it "shouldn't log the output on success" do
@@ -197,26 +176,6 @@ RSpec.describe Puppet::Type.type(:exec) do
       expect(@logs).to eq([])
     end
 
-    describe "when checks stop execution when debugging" do
-      [[:unless, :true], [:onlyif, :false]].each do |check, result|
-        it "should log a message with the command when #{check} is #{result}" do
-          output = "'#{@command}' won't be executed because of failed check '#{check}'"
-          test = exec_stub({:command => @command, check => result})
-          expect(test.check_all_attributes).to eq(false)
-          expect(@logs).to include(an_object_having_attributes(level: :debug, message: output))
-        end
-
-        it "should log a message with a redacted command and check if #{check} is sensitive" do
-          output1 = "Executing check '[redacted]'"
-          output2 = "'[command redacted]' won't be executed because of failed check '#{check}'"
-          test = exec_stub({:command => @command, check => result, :sensitive_parameters => [check]})
-          expect(test.check_all_attributes).to eq(false)
-          expect(@logs).to include(an_object_having_attributes(level: :debug, message: output1))
-          expect(@logs).to include(an_object_having_attributes(level: :debug, message: output2))
-        end
-      end
-    end
-
     describe " when multiple tries are set," do
       it "should repeat the command attempt 'tries' times on failure and produce an error" do
         tries = 5
@@ -274,15 +233,15 @@ RSpec.describe Puppet::Type.type(:exec) do
   describe "when setting user" do
     describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should fail if we are not root" do
-        allow(Puppet.features).to receive(:root?).and_return(false)
+        Puppet.features.stubs(:root?).returns(false)
         expect {
           Puppet::Type.type(:exec).new(:name => '/bin/true whatever', :user => 'input')
         }.to raise_error Puppet::Error, /Parameter user failed/
       end
 
       it "accepts the current user" do
-        allow(Puppet.features).to receive(:root?).and_return(false)
-        allow(Etc).to receive(:getpwuid).and_return(Struct::Passwd.new('input'))
+        Puppet.features.stubs(:root?).returns(false)
+        Etc.stubs(:getpwuid).returns(Struct::Passwd.new('input'))
 
         type = Puppet::Type.type(:exec).new(:name => '/bin/true whatever', :user => 'input')
 
@@ -291,16 +250,16 @@ RSpec.describe Puppet::Type.type(:exec) do
 
       ['one', 2, 'root', 4294967295, 4294967296].each do |value|
         it "should accept '#{value}' as user if we are root" do
-          allow(Puppet.features).to receive(:root?).and_return(true)
+          Puppet.features.stubs(:root?).returns(true)
           type = Puppet::Type.type(:exec).new(:name => '/bin/true whatever', :user => value)
           expect(type[:user]).to eq(value)
         end
       end
     end
 
-    describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
+    describe "on Windows systems", :if => Puppet::Util::Platform.windows? do
       before :each do
-        allow(Puppet.features).to receive(:root?).and_return(true)
+        Puppet.features.stubs(:root?).returns(true)
       end
 
       it "should reject user parameter" do
@@ -322,16 +281,12 @@ RSpec.describe Puppet::Type.type(:exec) do
     end
 
     describe "when running as root" do
-      before(:each) do
-        allow(Puppet.features).to receive(:root?).and_return(true)
-      end
+      before :each do Puppet.features.stubs(:root?).returns(true) end
       it_behaves_like "exec[:group]"
     end
 
     describe "when not running as root" do
-      before(:each) do
-        allow(Puppet.features).to receive(:root?).and_return(false)
-      end
+      before :each do Puppet.features.stubs(:root?).returns(false) end
       it_behaves_like "exec[:group]"
     end
   end
@@ -359,9 +314,9 @@ RSpec.describe Puppet::Type.type(:exec) do
             instance = Puppet::Type.type(:exec).new(:name => @executable)
           end
           if valid then
-            expect(instance.provider).to receive(:validatecmd).and_return(true)
+            instance.provider.expects(:validatecmd).returns(true)
           else
-            expect(instance.provider).to receive(:validatecmd).and_raise(Puppet::Error, "from a stub")
+            instance.provider.expects(:validatecmd).raises(Puppet::Error, "from a stub")
           end
           instance[@param] = command
         end
@@ -386,16 +341,16 @@ RSpec.describe Puppet::Type.type(:exec) do
 
       it "should accept the array when all commands return valid" do
         input = %w{one two three}
-        expect(@test.provider).to receive(:validatecmd).exactly(input.length).times.and_return(true)
+        @test.provider.expects(:validatecmd).times(input.length).returns(true)
         @test[param] = input
         expect(@test[param]).to eq(input)
       end
 
       it "should reject the array when any commands return invalid" do
         input = %w{one two three}
-        expect(@test.provider).to receive(:validatecmd).with(input.first).and_return(false)
+        @test.provider.expects(:validatecmd).with(input.first).returns(false)
         input[1..-1].each do |cmd|
-          expect(@test.provider).to receive(:validatecmd).with(cmd).and_return(true)
+          @test.provider.expects(:validatecmd).with(cmd).returns(true)
         end
         @test[param] = input
         expect(@test[param]).to eq(input)
@@ -403,7 +358,7 @@ RSpec.describe Puppet::Type.type(:exec) do
 
       it "should reject the array when all commands return invalid" do
         input = %w{one two three}
-        expect(@test.provider).to receive(:validatecmd).exactly(input.length).times.and_return(false)
+        @test.provider.expects(:validatecmd).times(input.length).returns(false)
         @test[param] = input
         expect(@test[param]).to eq(input)
       end
@@ -482,14 +437,14 @@ RSpec.describe Puppet::Type.type(:exec) do
           Puppet::Type.type(:exec).new(:name => "#{ruby_path} -e 'sleep 1'", :timeout => '0.1')
         end
 
-        context 'on POSIX', :unless => Puppet.features.microsoft_windows? do
+        context 'on POSIX', :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
           it 'sends a SIGTERM and raises a Puppet::Error' do
-            expect(Process).to receive(:kill).at_least(:once)
+            Process.expects(:kill).at_least_once
             expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
           end
         end
 
-        context 'on Windows', :if => Puppet.features.microsoft_windows? do
+        context 'on Windows', :if => Puppet::Util::Platform.windows? do
           it 'raises a Puppet::Error' do
             expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
           end
@@ -690,15 +645,15 @@ RSpec.describe Puppet::Type.type(:exec) do
           @pass = make_absolute("/magic/pass")
           @fail = make_absolute("/magic/fail")
 
-          @pass_status = double('status', :exitstatus => sense[:pass] ? 0 : 1)
-          @fail_status = double('status', :exitstatus => sense[:fail] ? 0 : 1)
+          @pass_status = stub('status', :exitstatus => sense[:pass] ? 0 : 1)
+          @fail_status = stub('status', :exitstatus => sense[:fail] ? 0 : 1)
 
-          allow(@test.provider).to receive(:checkexe).and_return(true)
+          @test.provider.stubs(:checkexe).returns(true)
           [true, false].each do |check|
-            allow(@test.provider).to receive(:run).with(@pass, check).
-              and_return(['test output', @pass_status])
-            allow(@test.provider).to receive(:run).with(@fail, check).
-              and_return(['test output', @fail_status])
+            @test.provider.stubs(:run).with(@pass, check).
+              returns(['test output', @pass_status])
+            @test.provider.stubs(:run).with(@fail, check).
+              returns(['test output', @fail_status])
           end
         end
 
@@ -749,15 +704,6 @@ RSpec.describe Puppet::Type.type(:exec) do
           expect(@test.check_all_attributes).to eq(true)
           expect(@logs.shift.message).to eq("test output")
         end
-
-        it "should not emit output to debug if sensitive is true" do
-          Puppet::Util::Log.level = :debug
-          @test[param] = @fail
-          allow(@test.parameters[param]).to receive(:sensitive).and_return(true)
-          expect(@test.check_all_attributes).to eq(true)
-          expect(@logs).not_to include(an_object_having_attributes(level: :debug, message: "test output"))
-          expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        end
       end
     end
   end
@@ -768,17 +714,17 @@ RSpec.describe Puppet::Type.type(:exec) do
     end
 
     it "should return :notrun when check_all_attributes returns true" do
-      allow(@exec_resource).to receive(:check_all_attributes).and_return(true)
+      @exec_resource.stubs(:check_all_attributes).returns true
       expect(@exec_resource.retrieve[:returns]).to eq(:notrun)
     end
 
     it "should return default exit code 0 when check_all_attributes returns false" do
-      allow(@exec_resource).to receive(:check_all_attributes).and_return(false)
+      @exec_resource.stubs(:check_all_attributes).returns false
       expect(@exec_resource.retrieve[:returns]).to eq(['0'])
     end
 
     it "should return the specified exit code when check_all_attributes returns false" do
-      allow(@exec_resource).to receive(:check_all_attributes).and_return(false)
+      @exec_resource.stubs(:check_all_attributes).returns false
       @exec_resource[:returns] = 42
       expect(@exec_resource.retrieve[:returns]).to eq(["42"])
     end
@@ -790,11 +736,11 @@ RSpec.describe Puppet::Type.type(:exec) do
     end
 
     it "should return the provider's run output" do
-      provider = double('provider')
-      status = double('process_status')
-      allow(status).to receive(:exitstatus).and_return("0")
-      expect(provider).to receive(:run).and_return(["silly output", status])
-      allow(@exec_resource).to receive(:provider).and_return(provider)
+      provider = stub 'provider'
+      status = stubs "process_status"
+      status.stubs(:exitstatus).returns("0")
+      provider.expects(:run).returns(["silly output", status])
+      @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh
       expect(@exec_resource.output).to eq('silly output')
@@ -808,29 +754,29 @@ RSpec.describe Puppet::Type.type(:exec) do
 
     it "should call provider run with the refresh parameter if it is set" do
       myother_bogus_cmd = make_absolute('/myother/bogus/cmd')
-      provider = double('provider')
-      allow(@exec_resource).to receive(:provider).and_return(provider)
-      allow(@exec_resource).to receive(:[]).with(:refresh).and_return(myother_bogus_cmd)
-      expect(provider).to receive(:run).with(myother_bogus_cmd)
+      provider = stub 'provider'
+      @exec_resource.stubs(:provider).returns(provider)
+      @exec_resource.stubs(:[]).with(:refresh).returns(myother_bogus_cmd)
+      provider.expects(:run).with(myother_bogus_cmd)
 
       @exec_resource.refresh
     end
 
     it "should call provider run with the specified command if the refresh parameter is not set" do
-      provider = double('provider')
-      status = double('process_status')
-      allow(status).to receive(:exitstatus).and_return("0")
-      expect(provider).to receive(:run).with(@bogus_cmd).and_return(["silly output", status])
-      allow(@exec_resource).to receive(:provider).and_return(provider)
+      provider = stub 'provider'
+      status = stubs "process_status"
+      status.stubs(:exitstatus).returns("0")
+      provider.expects(:run).with(@bogus_cmd).returns(["silly output", status])
+      @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh
     end
 
     it "should not run the provider if check_all_attributes is false" do
-      allow(@exec_resource).to receive(:check_all_attributes).and_return(false)
-      provider = double('provider')
-      expect(provider).not_to receive(:run)
-      allow(@exec_resource).to receive(:provider).and_return(provider)
+      @exec_resource.stubs(:check_all_attributes).returns false
+      provider = stub 'provider'
+      provider.expects(:run).never
+      @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh
     end

data/spec/unit/type/file/checksum_spec.rb

@@ -1,9 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 checksum = Puppet::Type.type(:file).attrclass(:checksum)
 describe checksum do
   before do
-    @path = Puppet.features.microsoft_windows? ? "c:/foo/bar" : "/foo/bar"
+    @path = Puppet::Util::Platform.windows? ? "c:/foo/bar" : "/foo/bar"
     @resource = Puppet::Type.type(:file).new :path => @path
     @checksum = @resource.parameter(:checksum)
   end
@@ -14,12 +15,12 @@ describe checksum do
 
   it "should use its current value when asked to sum content" do
     @checksum.value = :md5lite
-    expect(@checksum).to receive(:md5lite).with("foobar").and_return("yay")
+    @checksum.expects(:md5lite).with("foobar").returns "yay"
     @checksum.sum("foobar")
   end
 
   it "should use :md5 to sum when no value is set" do
-    expect(@checksum).to receive(:md5).with("foobar").and_return("yay")
+    @checksum.expects(:md5).with("foobar").returns "yay"
     @checksum.sum("foobar")
   end
 
@@ -53,36 +54,36 @@ describe checksum do
 
   it "should use its current value when asked to sum a file's content" do
     @checksum.value = :md5lite
-    expect(@checksum).to receive(:md5lite_file).with(@path).and_return("yay")
+    @checksum.expects(:md5lite_file).with(@path).returns "yay"
     @checksum.sum_file(@path)
   end
 
   it "should use :md5 to sum a file when no value is set" do
-    expect(@checksum).to receive(:md5_file).with(@path).and_return("yay")
+    @checksum.expects(:md5_file).with(@path).returns "yay"
     @checksum.sum_file(@path)
   end
 
   it "should convert all sums to strings when summing files" do
     @checksum.value = :mtime
-    expect(@checksum).to receive(:mtime_file).with(@path).and_return(Time.now)
+    @checksum.expects(:mtime_file).with(@path).returns Time.now
     expect { @checksum.sum_file(@path) }.not_to raise_error
   end
 
   it "should return the summed contents of a file with a checksum label" do
     @resource[:checksum] = :md5
-    expect(@checksum).to receive(:md5_file).and_return("mysum")
+    @checksum.expects(:md5_file).returns "mysum"
     expect(@checksum.sum_file(@path)).to eq("{md5}mysum")
   end
 
   it "should return the summed contents of a stream with a checksum label" do
     @resource[:checksum] = :md5
-    expect(@checksum).to receive(:md5_stream).and_return("mysum")
+    @checksum.expects(:md5_stream).returns "mysum"
     expect(@checksum.sum_stream).to eq("{md5}mysum")
   end
 
   it "should yield the sum_stream block to the underlying checksum" do
     @resource[:checksum] = :md5
-    expect(@checksum).to receive(:md5_stream).and_yield("something").and_return("mysum")
+    @checksum.expects(:md5_stream).yields("something").returns("mysum")
     @checksum.sum_stream do |sum|
       expect(sum).to eq("something")
     end
@@ -95,7 +96,7 @@ describe checksum do
   end
 
   it 'rejects md5 checksums in FIPS mode' do
-    allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(true)
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns true
     expect {
       @resource[:checksum] = :md5
     }.to raise_error(Puppet::ResourceError,