puppet 6.4.0-x64-mingw32 → 6.4.1-x64-mingw32

data/spec/unit/type/component_spec.rb

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

data/spec/unit/type/exec_spec.rb

@@ -1,11 +1,10 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:exec) do
+RSpec.describe Puppet::Type.type(:exec) do
   include PuppetSpec::Files
 
   def exec_tester(command, exitstatus = 0, rest = {})
-    Puppet.features.stubs(:root?).returns(true)
+    allow(Puppet.features).to receive(:root?).and_return(true)
 
     output = rest.delete(:output) || ''
 
@@ -21,12 +20,13 @@ 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)
 
-    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)
+      output
+    end.exactly(tries).times
 
     return exec
   end
@@ -44,12 +44,12 @@ describe Puppet::Type.type(:exec) do
     # 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)
-    dummy.provider.class.any_instance.stubs(:validatecmd)
-    dummy.provider.class.any_instance.stubs(:checkexe).returns(true)
-    pass_status = stub('status', :exitstatus => 0, :split => ["pass output"])
-    fail_status = stub('status', :exitstatus => 1, :split => ["fail output"])
-    Puppet::Util::Execution.stubs(:execute).with(:true, anything).returns(pass_status)
-    Puppet::Util::Execution.stubs(:execute).with(:false, anything).returns(fail_status)
+    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)
 
@@ -280,15 +280,15 @@ 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
-        Puppet.features.stubs(:root?).returns(false)
+        allow(Puppet.features).to receive(:root?).and_return(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
-        Puppet.features.stubs(:root?).returns(false)
-        Etc.stubs(:getpwuid).returns(Struct::Passwd.new('input'))
+        allow(Puppet.features).to receive(:root?).and_return(false)
+        allow(Etc).to receive(:getpwuid).and_return(Struct::Passwd.new('input'))
 
         type = Puppet::Type.type(:exec).new(:name => '/bin/true whatever', :user => 'input')
 
@@ -297,7 +297,7 @@ 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
-          Puppet.features.stubs(:root?).returns(true)
+          allow(Puppet.features).to receive(:root?).and_return(true)
           type = Puppet::Type.type(:exec).new(:name => '/bin/true whatever', :user => value)
           expect(type[:user]).to eq(value)
         end
@@ -306,7 +306,7 @@ describe Puppet::Type.type(:exec) do
 
     describe "on Windows systems", :if => Puppet::Util::Platform.windows? do
       before :each do
-        Puppet.features.stubs(:root?).returns(true)
+        allow(Puppet.features).to receive(:root?).and_return(true)
       end
 
       it "should reject user parameter" do
@@ -328,12 +328,16 @@ describe Puppet::Type.type(:exec) do
     end
 
     describe "when running as root" do
-      before :each do Puppet.features.stubs(:root?).returns(true) end
+      before(:each) do
+        allow(Puppet.features).to receive(:root?).and_return(true)
+      end
       it_behaves_like "exec[:group]"
     end
 
     describe "when not running as root" do
-      before :each do Puppet.features.stubs(:root?).returns(false) end
+      before(:each) do
+        allow(Puppet.features).to receive(:root?).and_return(false)
+      end
       it_behaves_like "exec[:group]"
     end
   end
@@ -361,9 +365,9 @@ describe Puppet::Type.type(:exec) do
             instance = Puppet::Type.type(:exec).new(:name => @executable)
           end
           if valid then
-            instance.provider.expects(:validatecmd).returns(true)
+            expect(instance.provider).to receive(:validatecmd).and_return(true)
           else
-            instance.provider.expects(:validatecmd).raises(Puppet::Error, "from a stub")
+            expect(instance.provider).to receive(:validatecmd).and_raise(Puppet::Error, "from a stub")
           end
           instance[@param] = command
         end
@@ -388,16 +392,16 @@ describe Puppet::Type.type(:exec) do
 
       it "should accept the array when all commands return valid" do
         input = %w{one two three}
-        @test.provider.expects(:validatecmd).times(input.length).returns(true)
+        expect(@test.provider).to receive(:validatecmd).exactly(input.length).times.and_return(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}
-        @test.provider.expects(:validatecmd).with(input.first).returns(false)
+        expect(@test.provider).to receive(:validatecmd).with(input.first).and_return(false)
         input[1..-1].each do |cmd|
-          @test.provider.expects(:validatecmd).with(cmd).returns(true)
+          expect(@test.provider).to receive(:validatecmd).with(cmd).and_return(true)
         end
         @test[param] = input
         expect(@test[param]).to eq(input)
@@ -405,7 +409,7 @@ describe Puppet::Type.type(:exec) do
 
       it "should reject the array when all commands return invalid" do
         input = %w{one two three}
-        @test.provider.expects(:validatecmd).times(input.length).returns(false)
+        expect(@test.provider).to receive(:validatecmd).exactly(input.length).times.and_return(false)
         @test[param] = input
         expect(@test[param]).to eq(input)
       end
@@ -486,7 +490,7 @@ describe Puppet::Type.type(:exec) do
 
         context 'on POSIX', :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
           it 'sends a SIGTERM and raises a Puppet::Error' do
-            Process.expects(:kill).at_least_once
+            expect(Process).to receive(:kill).at_least(:once)
             expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
           end
         end
@@ -708,15 +712,15 @@ describe Puppet::Type.type(:exec) do
           @pass = make_absolute("/magic/pass")
           @fail = make_absolute("/magic/fail")
 
-          @pass_status = stub('status', :exitstatus => sense[:pass] ? 0 : 1)
-          @fail_status = stub('status', :exitstatus => sense[:fail] ? 0 : 1)
+          @pass_status = double('status', :exitstatus => sense[:pass] ? 0 : 1)
+          @fail_status = double('status', :exitstatus => sense[:fail] ? 0 : 1)
 
-          @test.provider.stubs(:checkexe).returns(true)
+          allow(@test.provider).to receive(:checkexe).and_return(true)
           [true, false].each do |check|
-            @test.provider.stubs(:run).with(@pass, check).
-              returns(['test output', @pass_status])
-            @test.provider.stubs(:run).with(@fail, check).
-              returns(['test output', @fail_status])
+            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])
           end
         end
 
@@ -777,17 +781,17 @@ describe Puppet::Type.type(:exec) do
     end
 
     it "should return :notrun when check_all_attributes returns true" do
-      @exec_resource.stubs(:check_all_attributes).returns true
+      allow(@exec_resource).to receive(:check_all_attributes).and_return(true)
       expect(@exec_resource.retrieve[:returns]).to eq(:notrun)
     end
 
     it "should return default exit code 0 when check_all_attributes returns false" do
-      @exec_resource.stubs(:check_all_attributes).returns false
+      allow(@exec_resource).to receive(:check_all_attributes).and_return(false)
       expect(@exec_resource.retrieve[:returns]).to eq(['0'])
     end
 
     it "should return the specified exit code when check_all_attributes returns false" do
-      @exec_resource.stubs(:check_all_attributes).returns false
+      allow(@exec_resource).to receive(:check_all_attributes).and_return(false)
       @exec_resource[:returns] = 42
       expect(@exec_resource.retrieve[:returns]).to eq(["42"])
     end
@@ -799,11 +803,11 @@ describe Puppet::Type.type(:exec) do
     end
 
     it "should return the provider's run output" do
-      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)
+      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)
 
       @exec_resource.refresh
       expect(@exec_resource.output).to eq('silly output')
@@ -817,29 +821,29 @@ 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 = stub 'provider'
-      @exec_resource.stubs(:provider).returns(provider)
-      @exec_resource.stubs(:[]).with(:refresh).returns(myother_bogus_cmd)
-      provider.expects(:run).with(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)
 
       @exec_resource.refresh
     end
 
     it "should call provider run with the specified command if the refresh parameter is not set" do
-      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)
+      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)
 
       @exec_resource.refresh
     end
 
     it "should not run the provider if check_all_attributes is false" do
-      @exec_resource.stubs(:check_all_attributes).returns false
-      provider = stub 'provider'
-      provider.expects(:run).never
-      @exec_resource.stubs(:provider).returns(provider)
+      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.refresh
     end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 checksum = Puppet::Type.type(:file).attrclass(:checksum)
@@ -15,12 +14,12 @@ describe checksum do
 
   it "should use its current value when asked to sum content" do
     @checksum.value = :md5lite
-    @checksum.expects(:md5lite).with("foobar").returns "yay"
+    expect(@checksum).to receive(:md5lite).with("foobar").and_return("yay")
     @checksum.sum("foobar")
   end
 
   it "should use :md5 to sum when no value is set" do
-    @checksum.expects(:md5).with("foobar").returns "yay"
+    expect(@checksum).to receive(:md5).with("foobar").and_return("yay")
     @checksum.sum("foobar")
   end
 
@@ -54,36 +53,36 @@ describe checksum do
 
   it "should use its current value when asked to sum a file's content" do
     @checksum.value = :md5lite
-    @checksum.expects(:md5lite_file).with(@path).returns "yay"
+    expect(@checksum).to receive(:md5lite_file).with(@path).and_return("yay")
     @checksum.sum_file(@path)
   end
 
   it "should use :md5 to sum a file when no value is set" do
-    @checksum.expects(:md5_file).with(@path).returns "yay"
+    expect(@checksum).to receive(:md5_file).with(@path).and_return("yay")
     @checksum.sum_file(@path)
   end
 
   it "should convert all sums to strings when summing files" do
     @checksum.value = :mtime
-    @checksum.expects(:mtime_file).with(@path).returns Time.now
+    expect(@checksum).to receive(:mtime_file).with(@path).and_return(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
-    @checksum.expects(:md5_file).returns "mysum"
+    expect(@checksum).to receive(:md5_file).and_return("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
-    @checksum.expects(:md5_stream).returns "mysum"
+    expect(@checksum).to receive(:md5_stream).and_return("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
-    @checksum.expects(:md5_stream).yields("something").returns("mysum")
+    expect(@checksum).to receive(:md5_stream).and_yield("something").and_return("mysum")
     @checksum.sum_stream do |sum|
       expect(sum).to eq("something")
     end
@@ -96,7 +95,7 @@ describe checksum do
   end
 
   it 'rejects md5 checksums in FIPS mode' do
-    Puppet::Util::Platform.stubs(:fips_enabled?).returns true
+    allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(true)
     expect {
       @resource[:checksum] = :md5
     }.to raise_error(Puppet::ResourceError,

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums => true do
@@ -19,7 +18,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
     let(:checksum_value) { described_class.new(:resource => resource) }
 
     it "should not compute a checksum if source is absent" do
-      resource.expects(:stat).never
+      expect(resource).not_to receive(:stat)
       expect(checksum_value.retrieve).to be_nil
     end
 
@@ -29,21 +28,21 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
       end
 
       it "should return :absent if the target does not exist" do
-        resource.expects(:stat).returns nil
+        expect(resource).to receive(:stat).and_return(nil)
 
         expect(checksum_value.retrieve).to eq(:absent)
       end
 
       it "should not manage content on directories" do
-        stat = mock 'stat', :ftype => "directory"
-        resource.expects(:stat).returns stat
+        stat = double('stat', :ftype => "directory")
+        expect(resource).to receive(:stat).and_return(stat)
 
         expect(checksum_value.retrieve).to be_nil
       end
 
       it "should not manage content on links" do
-        stat = mock 'stat', :ftype => "link"
-        resource.expects(:stat).returns stat
+        stat = double('stat', :ftype => "link")
+        expect(resource).to receive(:stat).and_return(stat)
 
         expect(checksum_value.retrieve).to be_nil
       end
@@ -51,11 +50,11 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
       it "should always return the checksum as a string" do
         resource[:checksum] = :mtime
 
-        stat = mock 'stat', :ftype => "file"
-        resource.expects(:stat).returns stat
+        stat = double('stat', :ftype => "file")
+        expect(resource).to receive(:stat).and_return(stat)
 
         time = Time.now
-        resource.parameter(:checksum).expects(:mtime_file).with(resource[:path]).returns time
+        expect(resource.parameter(:checksum)).to receive(:mtime_file).with(resource[:path]).and_return(time)
 
         expect(checksum_value.retrieve).to eq(time.to_s)
       end
@@ -63,9 +62,9 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
 
     with_digest_algorithms do
       it "should return the checksum of the target if it exists and is a normal file" do
-        stat = mock 'stat', :ftype => "file"
-        resource.expects(:stat).returns stat
-        resource.parameter(:checksum).expects("#{digest_algorithm}_file".intern).with(resource[:path]).returns "mysum"
+        stat = double('stat', :ftype => "file")
+        expect(resource).to receive(:stat).and_return(stat)
+        expect(resource.parameter(:checksum)).to receive("#{digest_algorithm}_file".intern).with(resource[:path]).and_return("mysum")
         resource[:source] = source_file
 
         expect(checksum_value.retrieve).to eq("mysum")
@@ -96,7 +95,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
         end
 
         it "should return true if the resource shouldn't be a regular file" do
-          resource.expects(:should_be_file?).returns false
+          expect(resource).to receive(:should_be_file?).and_return(false)
           checksum_value.should = "foo"
           expect(checksum_value).to be_safe_insync("whatever")
         end
@@ -107,7 +106,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
         end
 
         it "should return false if the file should be a file but is not present" do
-          resource.expects(:should_be_file?).returns true
+          expect(resource).to receive(:should_be_file?).and_return(true)
           checksum_value.should = "foo"
 
           expect(checksum_value).not_to be_safe_insync(:absent)
@@ -115,7 +114,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
 
         describe "and the file exists" do
           before do
-            resource.stubs(:stat).returns mock("stat")
+            allow(resource).to receive(:stat).and_return(double("stat"))
             checksum_value.should = "somechecksum"
           end
 
@@ -135,19 +134,19 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
             describe "and Puppet[:show_diff] is #{cfg} and show_diff => #{param}" do
               before do
                 Puppet[:show_diff] = cfg
-                resource.stubs(:show_diff?).returns param
+                allow(resource).to receive(:show_diff?).and_return(param)
                 resource[:loglevel] = "debug"
               end
 
               if cfg and param
                 it "should display a diff" do
-                  checksum_value.expects(:diff).returns("my diff").once
-                  checksum_value.expects(:debug).with("\nmy diff").once
+                  expect(checksum_value).to receive(:diff).and_return("my diff").once
+                  expect(checksum_value).to receive(:debug).with("\nmy diff").once
                   expect(checksum_value).not_to be_safe_insync("otherchecksum")
                 end
               else
                 it "should not display a diff" do
-                  checksum_value.expects(:diff).never
+                  expect(checksum_value).not_to receive(:diff)
                   expect(checksum_value).not_to be_safe_insync("otherchecksum")
                 end
               end
@@ -202,17 +201,17 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
 
       describe "and :replace is false" do
         before do
-          resource.stubs(:replace?).returns false
+          allow(resource).to receive(:replace?).and_return(false)
         end
 
         it "should be insync if the file exists and the checksum_value is different" do
-          resource.stubs(:stat).returns mock('stat')
+          allow(resource).to receive(:stat).and_return(double('stat'))
 
           expect(checksum_value).to be_safe_insync("whatever")
         end
 
         it "should be insync if the file exists and the checksum_value is right" do
-          resource.stubs(:stat).returns mock('stat')
+          allow(resource).to receive(:stat).and_return(double('stat'))
 
           expect(checksum_value).to be_safe_insync("something")
         end
@@ -231,7 +230,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
         before do
           @new_resource = Puppet::Type.type(:file).new :ensure => :file, :path => path, :catalog => catalog,
             :checksum_value => checksum, :checksum => checksum_type, :source => source_file
-          @new_resource.stubs(:stat).returns mock('stat')
+          allow(@new_resource).to receive(:stat).and_return(double('stat'))
         end
 
         it "should return false if the current checksum_value is different from the desired checksum_value" do
@@ -249,12 +248,12 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
     let(:checksum_value) { described_class.new(:resource => resource) }
 
     before do
-      resource.stubs(:[]).with(:path).returns "/boo"
-      resource.stubs(:stat).returns "eh"
+      allow(resource).to receive(:[]).with(:path).and_return("/boo")
+      allow(resource).to receive(:stat).and_return("eh")
     end
 
     it "should raise if source is absent" do
-      resource.expects(:write).never
+      expect(resource).not_to receive(:write)
 
       expect { checksum_value.sync }.to raise_error "checksum_value#sync should not be called without a source parameter"
     end
@@ -265,20 +264,20 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
       end
 
       it "should use the file's :write method to write the checksum_value" do
-        resource.expects(:write).with(resource.parameter(:source))
+        expect(resource).to receive(:write).with(resource.parameter(:source))
 
         checksum_value.sync
       end
 
       it "should return :file_changed if the file already existed" do
-        resource.expects(:stat).returns "something"
-        resource.stubs(:write)
+        expect(resource).to receive(:stat).and_return("something")
+        allow(resource).to receive(:write)
         expect(checksum_value.sync).to eq(:file_changed)
       end
 
       it "should return :file_created if the file did not exist" do
-        resource.expects(:stat).returns nil
-        resource.stubs(:write)
+        expect(resource).to receive(:stat).and_return(nil)
+        allow(resource).to receive(:write)
         expect(checksum_value.sync).to eq(:file_created)
       end
     end