(PUP-11634) Expect hash arguments instead of keywords

This is a continuation of commit 1480189. If a method is called with a hash,
then the expectation must also be a hash, not keyword arguments.

Author: joshcooper

spec/unit/application/agent_spec.rb

@@ -524,7 +524,7 @@ def run(options = {}); end
       end
 
       it "should stop the daemon" do
-        expect(@daemon).to receive(:stop).with(:exit => false)
+        expect(@daemon).to receive(:stop).with({:exit => false})
 
         expect { execute_agent }.to exit_with 0
       end

spec/unit/application/device_spec.rb

@@ -535,7 +535,7 @@
         end
 
         it "makes the Puppet::Pops::Loaders available" do
-          expect(configurer).to receive(:run).with(:network_device => true, :pluginsync => false) do
+          expect(configurer).to receive(:run).with({:network_device => true, :pluginsync => false}) do
             fail('Loaders not available') unless Puppet.lookup(:loaders) { nil }.is_a?(Puppet::Pops::Loaders)
             true
           end.and_return(6, 2)

spec/unit/application/resource_spec.rb

@@ -122,7 +122,7 @@
       allow(@resource_app.command_line).to receive(:args).and_return(['type','name','param=temp'])
 
       expect(Puppet::Resource.indirection).to receive(:save).with(@res, 'type/name').and_return([@res, @report])
-      expect(Puppet::Resource).to receive(:new).with('type', 'name', :parameters => {'param' => 'temp'}).and_return(@res)
+      expect(Puppet::Resource).to receive(:new).with('type', 'name', {:parameters => {'param' => 'temp'}}).and_return(@res)
 
       @resource_app.main
     end

spec/unit/daemon_spec.rb

@@ -180,7 +180,7 @@ def run_loop(jobs)
 
     it "should shut down without exiting" do
       daemon.argv = %w{foo}
-      expect(daemon).to receive(:stop).with(:exit => false)
+      expect(daemon).to receive(:stop).with({:exit => false})
       daemon.reexec
     end
 

spec/unit/file_bucket/dipper_spec.rb

@@ -322,7 +322,7 @@ def make_tmp_file(contents)
         file = make_tmp_file(plaintext)
 
         expect(Puppet::FileBucket::File.indirection).to receive(:head).with(
-          %r{#{digest_algorithm}/#{checksum}}, :bucket_path => "/my/bucket"
+          %r{#{digest_algorithm}/#{checksum}}, {:bucket_path => "/my/bucket"}
         ).and_return(true)
         expect(Puppet::FileBucket::File.indirection).not_to receive(:save)
         expect(@dipper.backup(file)).to eq(checksum)

spec/unit/file_serving/fileset_spec.rb

@@ -153,12 +153,12 @@ def mock_dir_structure(path, stat_method = :lstat)
       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 @@ def mock_big_dir_structure(path, stat_method = :lstat)
       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 @@ def mock_big_dir_structure(path, stat_method = :lstat)
     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 @@ def directory?
     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 @@ def directory?
 
       @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 @@ def directory?
     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

spec/unit/graph/simple_graph_spec.rb

@@ -475,7 +475,7 @@ def expect_cycle_to_include(cycle, *resource_names)
 
     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

spec/unit/indirector/file_server_spec.rb

@@ -183,10 +183,10 @@ class Puppet::FileTestModel::FileServer < Puppet::Indirector::FileServer
       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 @@ class Puppet::FileTestModel::FileServer < Puppet::Indirector::FileServer
       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 @@ class Puppet::FileTestModel::FileServer < Puppet::Indirector::FileServer
       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 @@ class Puppet::FileTestModel::FileServer < Puppet::Indirector::FileServer
       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)

spec/unit/indirector/node/plain_spec.rb

@@ -21,7 +21,7 @@
   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)

spec/unit/provider/ldap_spec.rb

@@ -73,7 +73,7 @@
       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")
 

spec/unit/provider/nameservice_spec.rb

@@ -199,7 +199,7 @@ def modifycmd(param, value)
     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 ]
       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

spec/unit/provider/package/aix_spec.rb

@@ -16,7 +16,7 @@
 
   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
 

spec/unit/provider/package/nim_spec.rb

@@ -158,14 +158,14 @@
     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

spec/unit/provider/service/bsd_spec.rb

@@ -94,13 +94,13 @@
 
     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 @@
 
     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

spec/unit/provider/service/debian_spec.rb

@@ -87,7 +87,7 @@
 
   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 @@
 
     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