puppet 7.21.0-x64-mingw32 → 7.22.0-x64-mingw32

data/spec/unit/file_serving/fileset_spec.rb

@@ -153,12 +153,12 @@ describe Puppet::FileServing::Fileset do
       top_names = %w{one two .svn CVS}
       sub_names = %w{file1 file2 .svn CVS 0 false}
 
-      allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(top_names)
+      allow(Dir).to receive(:entries).with(path, {encoding: Encoding::UTF_8}).and_return(top_names)
       top_names.each do |subdir|
         @files << subdir # relative path
         subpath = File.join(path, subdir)
         allow(Puppet::FileSystem).to receive(stat_method).with(subpath).and_return(@dirstat)
-        allow(Dir).to receive(:entries).with(subpath, encoding: Encoding::UTF_8).and_return(sub_names)
+        allow(Dir).to receive(:entries).with(subpath, {encoding: Encoding::UTF_8}).and_return(sub_names)
         sub_names.each do |file|
           @files << File.join(subdir, file) # relative path
           subfile_path = File.join(subpath, file)
@@ -176,12 +176,12 @@ describe Puppet::FileServing::Fileset do
       top_names = (1..10).map {|i| "dir_#{i}" }
       sub_names = (1..100).map {|i| "file__#{i}" }
 
-      allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(top_names)
+      allow(Dir).to receive(:entries).with(path, {encoding: Encoding::UTF_8}).and_return(top_names)
       top_names.each do |subdir|
         @files << subdir # relative path
         subpath = File.join(path, subdir)
         allow(Puppet::FileSystem).to receive(stat_method).with(subpath).and_return(@dirstat)
-        allow(Dir).to receive(:entries).with(subpath, encoding: Encoding::UTF_8).and_return(sub_names)
+        allow(Dir).to receive(:entries).with(subpath, {encoding: Encoding::UTF_8}).and_return(sub_names)
         sub_names.each do |file|
           @files << File.join(subdir, file) # relative path
           subfile_path = File.join(subpath, file)
@@ -193,7 +193,7 @@ describe Puppet::FileServing::Fileset do
     def setup_mocks_for_dir(mock_dir, base_path)
       path = File.join(base_path, mock_dir.name)
       allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(MockStat.new(path, true))
-      allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(['.', '..'] + mock_dir.entries.map(&:name))
+      allow(Dir).to receive(:entries).with(path, {encoding: Encoding::UTF_8}).and_return(['.', '..'] + mock_dir.entries.map(&:name))
       mock_dir.entries.each do |entry|
         setup_mocks_for_entry(entry, path)
       end
@@ -360,7 +360,7 @@ describe Puppet::FileServing::Fileset do
     link_path = File.join(path, "mylink")
     expect(Puppet::FileSystem).to receive(:stat).with(link_path).and_raise(Errno::ENOENT)
 
-    allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(["mylink"])
+    allow(Dir).to receive(:entries).with(path, {encoding: Encoding::UTF_8}).and_return(["mylink"])
 
     fileset = Puppet::FileServing::Fileset.new(path)
 
@@ -377,16 +377,16 @@ describe Puppet::FileServing::Fileset do
 
       @filesets = @paths.collect do |path|
         allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double('stat', :directory? => true))
-        Puppet::FileServing::Fileset.new(path, :recurse => true)
+        Puppet::FileServing::Fileset.new(path, {:recurse => true})
       end
 
       allow(Dir).to receive(:entries).and_return([])
     end
 
     it "returns a hash of all files in each fileset with the value being the base path" do
-      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).and_return(%w{one uno})
-      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).and_return(%w{two dos})
-      expect(Dir).to receive(:entries).with(make_absolute("/third/path"), encoding: Encoding::UTF_8).and_return(%w{three tres})
+      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), {encoding: Encoding::UTF_8}).and_return(%w{one uno})
+      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), {encoding: Encoding::UTF_8}).and_return(%w{two dos})
+      expect(Dir).to receive(:entries).with(make_absolute("/third/path"), {encoding: Encoding::UTF_8}).and_return(%w{three tres})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)).to eq({
         "." => make_absolute("/first/path"),
@@ -400,15 +400,15 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "includes the base directory from the first fileset" do
-      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).and_return(%w{one})
-      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).and_return(%w{two})
+      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), {encoding: Encoding::UTF_8}).and_return(%w{one})
+      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), {encoding: Encoding::UTF_8}).and_return(%w{two})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["."]).to eq(make_absolute("/first/path"))
     end
 
     it "uses the base path of the first found file when relative file paths conflict" do
-      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).and_return(%w{one})
-      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).and_return(%w{one})
+      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), {encoding: Encoding::UTF_8}).and_return(%w{one})
+      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), {encoding: Encoding::UTF_8}).and_return(%w{one})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["one"]).to eq(make_absolute("/first/path"))
     end

data/spec/unit/file_system_spec.rb

@@ -819,9 +819,11 @@ describe "Puppet::FileSystem" do
         mode = Puppet::FileSystem.stat(dir).mode
         Puppet::FileSystem.chmod(0, dir)
         begin
+          # JRuby 9.2.21.0 drops the path from the message..
+          message = Puppet::Util::Platform.jruby? ? /^Permission denied/ : /^Permission denied .* #{path}/
           expect {
             Puppet::FileSystem.unlink(path)
-          }.to raise_error(Errno::EACCES, /^Permission denied .* #{path}/)
+          }.to raise_error(Errno::EACCES, message)
         ensure
           Puppet::FileSystem.chmod(mode, dir)
         end

data/spec/unit/graph/simple_graph_spec.rb

@@ -475,7 +475,7 @@ describe Puppet::Graph::SimpleGraph do
 
     it "should write a dot file based on the passed name" do
       expect(File).to receive(:open).with(@file, "w:UTF-8").and_yield(double("file", :puts => nil))
-      expect(@graph).to receive(:to_dot).with("name" => @name.to_s.capitalize)
+      expect(@graph).to receive(:to_dot).with({"name" => @name.to_s.capitalize})
       Puppet[:graph] = true
       @graph.write_graph(@name)
     end

data/spec/unit/indirector/facts/facter_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'puppet/indirector/facts/facter'
 
+class Puppet::Node::Facts::Facter::MyCollection < Hash; end
+
 describe Puppet::Node::Facts::Facter do
   FS = Puppet::FileSystem
 
@@ -87,11 +89,24 @@ describe Puppet::Node::Facts::Facter do
     it "can exclude legacy facts" do
       Puppet[:include_legacy_facts] = false
 
-      facts = Puppet::Node::Facts.new("foo")
-      expect(Puppet::Node::Facts).to receive(:new).and_return(facts)
       expect(Puppet.runtime[:facter]).to receive(:resolve).with('')
+        .and_return({'kernelversion' => '1.2.3'})
 
-      @facter.find(@request)
+      values = @facter.find(@request).values
+      expect(values).to be_an_instance_of(Hash)
+      expect(values).to include({'kernelversion' => '1.2.3'})
+    end
+
+    it "can exclude legacy facts using buggy facter implementations that return a Hash subclass" do
+      Puppet[:include_legacy_facts] = false
+
+      collection = Puppet::Node::Facts::Facter::MyCollection["kernelversion" => '1.2.3']
+      expect(Puppet.runtime[:facter]).to receive(:resolve).with('')
+        .and_return(collection)
+
+      values = @facter.find(@request).values
+      expect(values).to be_an_instance_of(Hash)
+      expect(values).to include({'kernelversion' => '1.2.3'})
     end
   end
 

data/spec/unit/indirector/file_server_spec.rb

@@ -183,10 +183,10 @@ describe Puppet::Indirector::FileServer do
       expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one", "two" => "/two")
 
       one = double('one', :collect => nil)
-      expect(model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
+      expect(model).to receive(:new).with("/one", {:relative_path => "one"}).and_return(one)
 
       two = double('two', :collect => nil)
-      expect(model).to receive(:new).with("/two", :relative_path => "two").and_return(two)
+      expect(model).to receive(:new).with("/two", {:relative_path => "two"}).and_return(two)
 
       # order can't be guaranteed
       result = indirection.search(uri)
@@ -205,7 +205,7 @@ describe Puppet::Indirector::FileServer do
       expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
 
       one = double('one', :collect => nil)
-      expect(model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
+      expect(model).to receive(:new).with("/one", {:relative_path => "one"}).and_return(one)
       expect(one).to receive(:links=).with(true)
 
       indirection.search(uri, links: true)
@@ -221,7 +221,7 @@ describe Puppet::Indirector::FileServer do
       expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
 
       one = double('one', :collect => nil)
-      expect(model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
+      expect(model).to receive(:new).with("/one", {:relative_path => "one"}).and_return(one)
 
       expect(one).to receive(:checksum_type=).with(:checksum)
 
@@ -238,7 +238,7 @@ describe Puppet::Indirector::FileServer do
       expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
 
       one = double('one')
-      expect(model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
+      expect(model).to receive(:new).with("/one", {:relative_path => "one"}).and_return(one)
       expect(one).to receive(:collect)
 
       indirection.search(uri)

data/spec/unit/indirector/node/plain_spec.rb

@@ -21,7 +21,7 @@ describe Puppet::Node::Plain do
   end
 
   it "should find facts if none are supplied" do
-    expect(Puppet::Node::Facts.indirection).to receive(:find).with(nodename, :environment => environment).and_return(indirection_facts)
+    expect(Puppet::Node::Facts.indirection).to receive(:find).with(nodename, {:environment => environment}).and_return(indirection_facts)
     request.options.delete(:facts)
     node = node_indirection.find(request)
     expect(node.parameters).to include(indirection_fact_values)

data/spec/unit/provider/file/posix_spec.rb

@@ -39,7 +39,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#uid2name" do
     it "should return the name of the user identified by the id" do
-      allow(Etc).to receive(:getpwuid).with(501).and_return(Struct::Passwd.new('jilluser', nil, 501))
+      allow(Etc).to receive(:getpwuid).with(501).and_return(Etc::Passwd.new('jilluser', nil, 501))
 
       expect(provider.uid2name(501)).to eq('jilluser')
     end
@@ -61,7 +61,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#name2uid" do
     it "should return the id of the user if it exists" do
-      passwd = Struct::Passwd.new('bobbo', nil, 502)
+      passwd = Etc::Passwd.new('bobbo', nil, 502)
 
       allow(Etc).to receive(:getpwnam).with('bobbo').and_return(passwd)
       allow(Etc).to receive(:getpwuid).with(502).and_return(passwd)
@@ -131,7 +131,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#gid2name" do
     it "should return the name of the group identified by the id" do
-      allow(Etc).to receive(:getgrgid).with(501).and_return(Struct::Passwd.new('unicorns', nil, nil, 501))
+      allow(Etc).to receive(:getgrgid).with(501).and_return(Etc::Passwd.new('unicorns', nil, nil, 501))
 
       expect(provider.gid2name(501)).to eq('unicorns')
     end
@@ -153,7 +153,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#name2gid" do
     it "should return the id of the group if it exists" do
-      passwd = Struct::Passwd.new('penguins', nil, nil, 502)
+      passwd = Etc::Passwd.new('penguins', nil, nil, 502)
 
       allow(Etc).to receive(:getgrnam).with('penguins').and_return(passwd)
       allow(Etc).to receive(:getgrgid).with(502).and_return(passwd)

data/spec/unit/provider/ldap_spec.rb

@@ -73,7 +73,7 @@ describe Puppet::Provider::Ldap do
       it "should create a provider with :ensure => :absent" do
         expect(@manager).to receive(:find).with("one").and_return(nil)
 
-        expect(@class).to receive(:new).with(:ensure => :absent).and_return("myprovider")
+        expect(@class).to receive(:new).with({:ensure => :absent}).and_return("myprovider")
 
         expect(@resource).to receive(:provider=).with("myprovider")
 

data/spec/unit/provider/nameservice_spec.rb

@@ -30,8 +30,8 @@ describe Puppet::Provider::NameService do
   # These are values getpwent might give you
   let :users do
     [
-      Struct::Passwd.new('root', 'x', 0, 0),
-      Struct::Passwd.new('foo', 'x', 1000, 2000),
+      Etc::Passwd.new('root', 'x', 0, 0),
+      Etc::Passwd.new('foo', 'x', 1000, 2000),
       nil
     ]
   end
@@ -39,13 +39,13 @@ describe Puppet::Provider::NameService do
   # These are values getgrent might give you
   let :groups do
     [
-      Struct::Group.new('root', 'x', 0, %w{root}),
-      Struct::Group.new('bin', 'x', 1, %w{root bin daemon}),
+      Etc::Group.new('root', 'x', 0, %w{root}),
+      Etc::Group.new('bin', 'x', 1, %w{root bin daemon}),
       nil
     ]
   end
 
-  # A fake struct besides Struct::Group and Struct::Passwd
+  # A fake struct besides Etc::Group and Etc::Passwd
   let :fakestruct do
     Struct.new(:foo, :bar)
   end
@@ -82,11 +82,11 @@ describe Puppet::Provider::NameService do
 
   let(:utf_8_mixed_users) {
     [
-      Struct::Passwd.new('root', 'x', 0, 0),
-      Struct::Passwd.new('foo', 'x', 1000, 2000),
-      Struct::Passwd.new(utf_8_jose, utf_8_jose, 1001, 2000), # UTF-8 character
+      Etc::Passwd.new('root', 'x', 0, 0),
+      Etc::Passwd.new('foo', 'x', 1000, 2000),
+      Etc::Passwd.new(utf_8_jose, utf_8_jose, 1001, 2000), # UTF-8 character
       # In a UTF-8 environment, ruby will return strings labeled as UTF-8 even if they're not valid in UTF-8
-      Struct::Passwd.new(invalid_utf_8_jose, invalid_utf_8_jose, 1002, 2000),
+      Etc::Passwd.new(invalid_utf_8_jose, invalid_utf_8_jose, 1002, 2000),
       nil
     ]
   }
@@ -94,10 +94,10 @@ describe Puppet::Provider::NameService do
   let(:latin_1_mixed_users) {
     [
       # In a LATIN-1 environment, ruby will return *all* strings labeled as LATIN-1
-      Struct::Passwd.new('root'.force_encoding(Encoding::ISO_8859_1), 'x', 0, 0),
-      Struct::Passwd.new('foo'.force_encoding(Encoding::ISO_8859_1), 'x', 1000, 2000),
-      Struct::Passwd.new(utf_8_labeled_as_latin_1_jose, utf_8_labeled_as_latin_1_jose, 1002, 2000),
-      Struct::Passwd.new(valid_latin1_jose, valid_latin1_jose, 1001, 2000), # UTF-8 character
+      Etc::Passwd.new('root'.force_encoding(Encoding::ISO_8859_1), 'x', 0, 0),
+      Etc::Passwd.new('foo'.force_encoding(Encoding::ISO_8859_1), 'x', 1000, 2000),
+      Etc::Passwd.new(utf_8_labeled_as_latin_1_jose, utf_8_labeled_as_latin_1_jose, 1002, 2000),
+      Etc::Passwd.new(valid_latin1_jose, valid_latin1_jose, 1001, 2000), # UTF-8 character
       nil
     ]
   }
@@ -197,9 +197,9 @@ describe Puppet::Provider::NameService do
     end
 
     it "should pass the Puppet::Etc :canonical_name Struct member to the constructor" do
-      users = [ Struct::Passwd.new(invalid_utf_8_jose, invalid_utf_8_jose, 1002, 2000), nil ]
+      users = [ Etc::Passwd.new(invalid_utf_8_jose, invalid_utf_8_jose, 1002, 2000), nil ]
       allow(Etc).to receive(:getpwent).and_return(*users)
-      expect(provider.class).to receive(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
+      expect(provider.class).to receive(:new).with({:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present})
       provider.class.instances
     end
   end

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

@@ -16,7 +16,7 @@ describe Puppet::Type.type(:package).provider(:aix) do
 
   it "should uninstall a package" do
     expect(@provider).to receive(:installp).with('-gu', 'mypackage')
-    expect(@provider.class).to receive(:pkglist).with(:pkgname => 'mypackage').and_return(nil)
+    expect(@provider.class).to receive(:pkglist).with({:pkgname => 'mypackage'}).and_return(nil)
     @provider.uninstall
   end
 

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

@@ -158,14 +158,14 @@ OUTPUT
     it "should call installp to uninstall a bff package" do
       expect(@provider).to receive(:lslpp).with("-qLc", "mypackage.foo").and_return("#bos.atm:bos.atm.atmle:7.1.2.0: : :C: :ATM LAN Emulation Client Support : : : : : : :0:0:/:1241")
       expect(@provider).to receive(:installp).with("-gu", "mypackage.foo")
-      expect(@provider.class).to receive(:pkglist).with(:pkgname => 'mypackage.foo').and_return(nil)
+      expect(@provider.class).to receive(:pkglist).with({:pkgname => 'mypackage.foo'}).and_return(nil)
       @provider.uninstall
     end
 
     it "should call rpm to uninstall an rpm package" do
       expect(@provider).to receive(:lslpp).with("-qLc", "mypackage.foo").and_return("cdrecord:cdrecord-1.9-6:1.9-6: : :C:R:A command line CD/DVD recording program.: :/bin/rpm -e cdrecord: : : : :0: :/opt/freeware:Wed Jun 29 09:41:32 PDT 2005")
       expect(@provider).to receive(:rpm).with("-e", "mypackage.foo")
-      expect(@provider.class).to receive(:pkglist).with(:pkgname => 'mypackage.foo').and_return(nil)
+      expect(@provider.class).to receive(:pkglist).with({:pkgname => 'mypackage.foo'}).and_return(nil)
       @provider.uninstall
     end
   end

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

@@ -94,13 +94,13 @@ describe 'Puppet::Type::Service::Provider::Bsd',
 
     it "should use the supplied start command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/bin/foo'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       provider.start
     end
 
     it "should start the serviced directly otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/rc.d/sshd', :onestart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/etc/rc.d/sshd', :onestart], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       expect(provider).to receive(:search).with('sshd').and_return('/etc/rc.d/sshd')
       provider.start
     end
@@ -113,13 +113,13 @@ describe 'Puppet::Type::Service::Provider::Bsd',
 
     it "should use the supplied stop command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/bin/foo'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       provider.stop
     end
 
     it "should stop the serviced directly otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/rc.d/sshd', :onestop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/etc/rc.d/sshd', :onestop], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       expect(provider).to receive(:search).with('sshd').and_return('/etc/rc.d/sshd')
       provider.stop
     end

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

@@ -87,7 +87,7 @@ describe 'Puppet::Type::Service::Provider::Debian',
 
   context "when checking whether it is enabled" do
     it "should execute the query command" do
-      expect(@provider).to receive(:execute).with(["/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start"], :failonfail => false)
+      expect(@provider).to receive(:execute).with(["/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start"], {:failonfail => false})
                              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
       @provider.enabled?
     end
@@ -104,7 +104,7 @@ describe 'Puppet::Type::Service::Provider::Debian',
 
     it "should consider nonexistent services to be disabled" do
       @provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'doesnotexist'))
-      expect(@provider).to receive(:execute).with(["/usr/sbin/invoke-rc.d", "--quiet", "--query", "doesnotexist", "start"], :failonfail => false)
+      expect(@provider).to receive(:execute).with(["/usr/sbin/invoke-rc.d", "--quiet", "--query", "doesnotexist", "start"], {:failonfail => false})
                              .and_return(Puppet::Util::Execution::ProcessOutput.new("", 1))
       expect(@provider.enabled?).to be(:false)
     end

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

@@ -79,13 +79,13 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
   describe "#start" do
     it "should use the supplied start command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/bin/foo'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       provider.start
     end
 
     it "should start the service with <initscript> start otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
       provider.start
     end
@@ -94,13 +94,13 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
   describe "#stop" do
     it "should use the supplied stop command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/bin/foo'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       provider.stop
     end
 
     it "should stop the service with <initscript> stop otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:stop], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
       provider.stop
     end
@@ -160,27 +160,27 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
     describe "when a special status command is specified" do
       it "should use the status command from the resource" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
         expect(provider).to receive(:execute)
-          .with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .with(['/bin/foo'], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
           .and_return(process_output)
         provider.status
       end
 
       it "should return :stopped when the status command returns with a non-zero exitcode" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
         expect(provider).to receive(:execute)
-          .with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .with(['/bin/foo'], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
           .and_return(Puppet::Util::Execution::ProcessOutput.new('', 3))
         expect(provider.status).to eq(:stopped)
       end
 
       it "should return :running when the status command returns with a zero exitcode" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
         expect(provider).to receive(:execute)
-          .with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .with(['/bin/foo'], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
           .and_return(process_output)
         expect(provider.status).to eq(:running)
       end
@@ -189,14 +189,14 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
     describe "when hasstatus is false" do
       it "should return running if a pid can be found" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
-        expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
         expect(provider).to receive(:getpid).and_return(1000)
         expect(provider.status).to eq(:running)
       end
 
       it "should return stopped if no pid can be found" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
-        expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
         expect(provider).to receive(:getpid).and_return(nil)
         expect(provider.status).to eq(:stopped)
       end
@@ -207,7 +207,7 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
         expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
         expect(provider).to receive(:execute)
-          .with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .with(['/etc/init.d/sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
           .and_return(process_output)
         expect(provider.status).to eq(:running)
       end
@@ -216,7 +216,7 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
         expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
         expect(provider).to receive(:execute)
-          .with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .with(['/etc/init.d/sshd',:status], {:failonfail => false, :override_locale => false, :squelch => false, :combine => true})
           .and_return(Puppet::Util::Execution::ProcessOutput.new('', 3))
         expect(provider.status).to eq(:stopped)
       end
@@ -226,24 +226,24 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
   describe "#restart" do
     it "should use the supplied restart command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
-      expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:restart], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+      expect(provider).to receive(:execute).with(['/bin/foo'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       provider.restart
     end
 
     it "should restart the service with <initscript> restart if hasrestart is true" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
       expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:restart], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       provider.restart
     end
 
     it "should restart the service with <initscript> stop/start if hasrestart is false" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
       expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-      expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:restart], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:stop], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       provider.restart
     end
   end