chef 12.19.36 → 14.14.25

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

@@ -44,18 +44,19 @@ describe Chef::Provider::Service::Macosx do
   context "when service name is given as" do
     let(:node) { Chef::Node.new }
     let(:events) { Chef::EventDispatch::Dispatcher.new }
+    let(:logger) { double("Mixlib::Log::Child").as_null_object }
     let(:run_context) { Chef::RunContext.new(node, {}, events) }
     let(:provider) { described_class.new(new_resource, run_context) }
     let(:launchctl_stdout) { StringIO.new }
-    let(:plutil_stdout) { String.new <<-XML }
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>io.redis.redis-server</string>
-</dict>
-</plist>
+    let(:plutil_stdout) { String.new <<~XML }
+      <?xml version="1.0" encoding="UTF-8"?>
+      <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+      <plist version="1.0">
+      <dict>
+        <key>Label</key>
+        <string>io.redis.redis-server</string>
+      </dict>
+      </plist>
 XML
 
     %w{Daemon Agent}.each do |service_type|
@@ -73,18 +74,22 @@ XML
           end
           let(:service_label) { "io.redis.redis-server" }
           before do
+            allow(run_context).to receive(:logger).and_return(logger)
             allow(Dir).to receive(:glob).and_return([plist], [])
-            allow(Etc).to receive(:getlogin).and_return("igor")
+            @stat = double("File::Stat", { uid: 501 })
+            allow(File).to receive(:stat).and_return(@stat)
+            @getpwuid = double("Etc::Passwd", { name: "mikedodge04" })
+            allow(Etc).to receive(:getpwuid).and_return(@getpwuid)
             allow(node).to receive(:[]).with("platform_version").and_return(platform_version)
             cmd = "launchctl list #{service_label}"
-            allow(provider).to receive(:shell_out_with_systems_locale).
-              with(/(#{su_cmd} '#{cmd}'|#{cmd})/).
-              and_return(double("Status",
-                                    :stdout => launchctl_stdout, :exitstatus => 0))
+            allow(provider).to receive(:shell_out)
+              .with(/(#{su_cmd} '#{cmd}'|#{cmd})/, default_env: false)
+              .and_return(double("Status",
+                                    stdout: launchctl_stdout, exitstatus: 0))
             allow(File).to receive(:exists?).and_return([true], [])
-            allow(provider).to receive(:shell_out_with_systems_locale!).
-              with(/plutil -convert xml1 -o/).
-              and_return(double("Status", :stdout => plutil_stdout))
+            allow(provider).to receive(:shell_out!)
+              .with(/plutil -convert xml1 -o/, default_env: false)
+              .and_return(double("Status", stdout: plutil_stdout))
           end
 
           context "#{service_name} that is a #{service_type} running Osx #{platform_version}" do
@@ -108,9 +113,9 @@ XML
                 before do
                   allow(Dir).to receive(:glob).and_return([])
                   allow(File).to receive(:exists?).and_return([true], [])
-                  allow(provider).to receive(:shell_out!).
-                    with(/plutil -convert xml1 -o/).
-                    and_raise(Mixlib::ShellOut::ShellCommandFailed)
+                  allow(provider).to receive(:shell_out!)
+                    .with(/plutil -convert xml1 -o/)
+                    .and_raise(Mixlib::ShellOut::ShellCommandFailed)
                 end
 
                 it "works for action :nothing" do
@@ -131,20 +136,20 @@ XML
               end
 
               context "when launchctl returns pid in service list" do
-                let(:launchctl_stdout) { StringIO.new <<-SVC_LIST }
-{
-  "LimitLoadToSessionType" = "System";
-  "Label" = "io.redis.redis-server";
-  "TimeOut" = 30;
-  "OnDemand" = false;
-  "LastExitStatus" = 0;
-  "PID" = 62803;
-  "Program" = "do_some.sh";
-  "ProgramArguments" = (
-    "path/to/do_something.sh";
-    "-f";
-  );
-};
+                let(:launchctl_stdout) { StringIO.new <<~SVC_LIST }
+                  {
+                    "LimitLoadToSessionType" = "System";
+                    "Label" = "io.redis.redis-server";
+                    "TimeOut" = 30;
+                    "OnDemand" = false;
+                    "LastExitStatus" = 0;
+                    "PID" = 62803;
+                    "Program" = "do_some.sh";
+                    "ProgramArguments" = (
+                      "path/to/do_something.sh";
+                      "-f";
+                    );
+                  };
 SVC_LIST
 
                 before do
@@ -162,7 +167,7 @@ SVC_LIST
 
               describe "running unsupported actions" do
                 before do
-                  allow(Dir).to receive(:glob).and_return(["#{plist}"], [])
+                  allow(Dir).to receive(:glob).and_return([(plist).to_s], [])
                   allow(File).to receive(:exists?).and_return([true], [])
                 end
                 it "should throw an exception when reload action is attempted" do
@@ -170,19 +175,19 @@ SVC_LIST
                 end
               end
               context "when launchctl returns empty service pid" do
-                let(:launchctl_stdout) { StringIO.new <<-SVC_LIST }
-{
-  "LimitLoadToSessionType" = "System";
-  "Label" = "io.redis.redis-server";
-  "TimeOut" = 30;
-  "OnDemand" = false;
-  "LastExitStatus" = 0;
-  "Program" = "do_some.sh";
-  "ProgramArguments" = (
-    "path/to/do_something.sh";
-    "-f";
-  );
-};
+                let(:launchctl_stdout) { StringIO.new <<~SVC_LIST }
+                  {
+                    "LimitLoadToSessionType" = "System";
+                    "Label" = "io.redis.redis-server";
+                    "TimeOut" = 30;
+                    "OnDemand" = false;
+                    "LastExitStatus" = 0;
+                    "Program" = "do_some.sh";
+                    "ProgramArguments" = (
+                      "path/to/do_something.sh";
+                      "-f";
+                    );
+                  };
 SVC_LIST
 
                 before do
@@ -199,8 +204,8 @@ SVC_LIST
               end
 
               context "when launchctl doesn't return service entry at all" do
-                let(:launchctl_stdout) { StringIO.new <<-SVC_LIST }
-Could not find service "io.redis.redis-server" in domain for system
+                let(:launchctl_stdout) { StringIO.new <<~SVC_LIST }
+                  Could not find service "io.redis.redis-server" in domain for system
 SVC_LIST
 
                 it "sets service running state to false" do
@@ -221,7 +226,7 @@ SVC_LIST
 
                 context "and plist for service is available" do
                   before do
-                    allow(Dir).to receive(:glob).and_return(["#{plist}"], [])
+                    allow(Dir).to receive(:glob).and_return([(plist).to_s], [])
                     provider.load_current_resource
                   end
 
@@ -232,7 +237,7 @@ SVC_LIST
 
                 describe "and several plists match service name" do
                   it "throws exception" do
-                    allow(Dir).to receive(:glob).and_return(["#{plist}",
+                    allow(Dir).to receive(:glob).and_return([(plist).to_s,
                                                 "/Users/wtf/something.plist"])
                     provider.load_current_resource
                     provider.define_resource_requirements
@@ -251,22 +256,22 @@ SVC_LIST
               it "calls the start command if one is specified and service is not running" do
                 allow(new_resource).to receive(:start_command).and_return("cowsay dirty")
 
-                expect(provider).to receive(:shell_out_with_systems_locale!).with("cowsay dirty")
+                expect(provider).to receive(:shell_out!).with("cowsay dirty", default_env: false)
                 provider.start_service
               end
 
               it "shows warning message if service is already running" do
                 allow(current_resource).to receive(:running).and_return(true)
-                expect(Chef::Log).to receive(:debug).with("macosx_service[#{service_name}] already running, not starting")
+                expect(logger).to receive(:trace).with("macosx_service[#{service_name}] already running, not starting")
 
                 provider.start_service
               end
 
               it "starts service via launchctl if service found" do
                 cmd = "launchctl load -w " + session + plist
-                expect(provider).to receive(:shell_out_with_systems_locale).
-                  with(/(#{su_cmd} .#{cmd}.|#{cmd})/).
-                  and_return(0)
+                expect(provider).to receive(:shell_out)
+                  .with(/(#{su_cmd} .#{cmd}.|#{cmd})/, default_env: false)
+                  .and_return(0)
 
                 provider.start_service
               end
@@ -283,22 +288,22 @@ SVC_LIST
               it "calls the stop command if one is specified and service is running" do
                 allow(new_resource).to receive(:stop_command).and_return("kill -9 123")
 
-                expect(provider).to receive(:shell_out_with_systems_locale!).with("kill -9 123")
+                expect(provider).to receive(:shell_out!).with("kill -9 123", default_env: false)
                 provider.stop_service
               end
 
               it "shows warning message if service is not running" do
                 allow(current_resource).to receive(:running).and_return(false)
-                expect(Chef::Log).to receive(:debug).with("macosx_service[#{service_name}] not running, not stopping")
+                expect(logger).to receive(:trace).with("macosx_service[#{service_name}] not running, not stopping")
 
                 provider.stop_service
               end
 
               it "stops the service via launchctl if service found" do
                 cmd = "launchctl unload -w " + plist
-                expect(provider).to receive(:shell_out_with_systems_locale).
-                  with(/(#{su_cmd} .#{cmd}.|#{cmd})/).
-                  and_return(0)
+                expect(provider).to receive(:shell_out)
+                  .with(/(#{su_cmd} .#{cmd}.|#{cmd})/, default_env: false)
+                  .and_return(0)
 
                 provider.stop_service
               end
@@ -316,7 +321,7 @@ SVC_LIST
               it "issues a command if given" do
                 allow(new_resource).to receive(:restart_command).and_return("reload that thing")
 
-                expect(provider).to receive(:shell_out_with_systems_locale!).with("reload that thing")
+                expect(provider).to receive(:shell_out!).with("reload that thing", default_env: false)
                 provider.restart_service
               end
 

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

@@ -31,11 +31,11 @@ end
 describe Chef::Provider::Service::Openbsd do
   let(:node) do
     node = Chef::Node.new
-    node.automatic_attrs[:command] = { :ps => "ps -ax" }
+    node.automatic_attrs[:command] = { ps: "ps -ax" }
     node
   end
 
-  let(:supports) { { :status => false } }
+  let(:supports) { { status: false } }
 
   let(:new_resource) do
     new_resource = Chef::Resource::Service.new("sndiod")
@@ -93,7 +93,7 @@ describe Chef::Provider::Service::Openbsd do
     end
 
     context "when a status command has been specified" do
-      let(:status) { double(:stdout => "", :exitstatus => 0) }
+      let(:status) { double(stdout: "", exitstatus: 0) }
 
       before do
         new_resource.status_command("/bin/chefhasmonkeypants status")
@@ -106,9 +106,9 @@ describe Chef::Provider::Service::Openbsd do
     end
 
     context "when the service supports status" do
-      let(:status) { double(:stdout => "", :exitstatus => 0) }
+      let(:status) { double(stdout: "", exitstatus: 0) }
 
-      let(:supports) { { :status => true } }
+      let(:supports) { { status: true } }
 
       it "should run '/etc/rc.d/service_name status'" do
         expect(provider).to receive(:shell_out).with("/etc/rc.d/#{new_resource.service_name} check").and_return(status)
@@ -189,7 +189,7 @@ describe Chef::Provider::Service::Openbsd do
         let(:lines) do
           [
           %Q{#{provider.builtin_service_enable_variable_name}_thing="YES"},
-          %Q{#{provider.builtin_service_enable_variable_name}},
+          (provider.builtin_service_enable_variable_name).to_s,
         ] end
         it "sets enabled based on the exact match (false)" do
           provider.determine_enabled_status!
@@ -285,12 +285,12 @@ describe Chef::Provider::Service::Openbsd do
     describe Chef::Provider::Service::Openbsd, "start_service" do
       it "should call the start command if one is specified" do
         new_resource.start_command("/etc/rc.d/chef startyousillysally")
-        expect(provider).to receive(:shell_out_with_systems_locale!).with("/etc/rc.d/chef startyousillysally")
+        expect(provider).to receive(:shell_out!).with("/etc/rc.d/chef startyousillysally", default_env: false)
         provider.start_service()
       end
 
       it "should call '/usr/local/etc/rc.d/service_name start' if no start command is specified" do
-        expect(provider).to receive(:shell_out_with_systems_locale!).with("/etc/rc.d/#{new_resource.service_name} start")
+        expect(provider).to receive(:shell_out!).with("/etc/rc.d/#{new_resource.service_name} start", default_env: false)
         provider.start_service()
       end
     end
@@ -298,12 +298,12 @@ describe Chef::Provider::Service::Openbsd do
     describe Chef::Provider::Service::Openbsd, "stop_service" do
       it "should call the stop command if one is specified" do
         new_resource.stop_command("/etc/init.d/chef itoldyoutostop")
-        expect(provider).to receive(:shell_out_with_systems_locale!).with("/etc/init.d/chef itoldyoutostop")
+        expect(provider).to receive(:shell_out!).with("/etc/init.d/chef itoldyoutostop", default_env: false)
         provider.stop_service()
       end
 
       it "should call '/usr/local/etc/rc.d/service_name stop' if no stop command is specified" do
-        expect(provider).to receive(:shell_out_with_systems_locale!).with("/etc/rc.d/#{new_resource.service_name} stop")
+        expect(provider).to receive(:shell_out!).with("/etc/rc.d/#{new_resource.service_name} stop", default_env: false)
         provider.stop_service()
       end
     end
@@ -312,14 +312,14 @@ describe Chef::Provider::Service::Openbsd do
       context "when the new_resource supports restart" do
         let(:supports) { { restart: true } }
         it "should call 'restart' on the service_name if the resource supports it" do
-          expect(provider).to receive(:shell_out_with_systems_locale!).with("/etc/rc.d/#{new_resource.service_name} restart")
+          expect(provider).to receive(:shell_out!).with("/etc/rc.d/#{new_resource.service_name} restart", default_env: false)
           provider.restart_service()
         end
       end
 
       it "should call the restart_command if one has been specified" do
         new_resource.restart_command("/etc/init.d/chef restartinafire")
-        expect(provider).to receive(:shell_out_with_systems_locale!).with("/etc/init.d/chef restartinafire")
+        expect(provider).to receive(:shell_out!).with("/etc/init.d/chef restartinafire", default_env: false)
         provider.restart_service()
       end
 

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

@@ -23,17 +23,17 @@ shared_examples_for "define_resource_requirements_common" do
   it "should raise an error if /sbin/chkconfig does not exist" do
     allow(File).to receive(:exists?).with("/sbin/chkconfig").and_return(false)
     allow(@provider).to receive(:shell_out).with("/sbin/service chef status").and_raise(Errno::ENOENT)
-    allow(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_raise(Errno::ENOENT)
+    allow(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_raise(Errno::ENOENT)
     @provider.load_current_resource
     @provider.define_resource_requirements
     expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
   end
 
   it "should not raise an error if the service exists but is not added to any runlevels" do
-    status = double("Status", :exitstatus => 0, :stdout => "" , :stderr => "")
+    status = double("Status", exitstatus: 0, stdout: "" , stderr: "")
     expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
-    chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "", :stderr => "service chef supports chkconfig, but is not referenced in any runlevel (run 'chkconfig --add chef')")
-    expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_return(chkconfig)
+    chkconfig = double("Chkconfig", exitstatus: 0, stdout: "", stderr: "service chef supports chkconfig, but is not referenced in any runlevel (run 'chkconfig --add chef')")
+    expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_return(chkconfig)
     @provider.load_current_resource
     @provider.define_resource_requirements
     expect { @provider.process_resource_requirements }.not_to raise_error
@@ -44,7 +44,7 @@ describe "Chef::Provider::Service::Redhat" do
 
   before(:each) do
     @node = Chef::Node.new
-    @node.automatic_attrs[:command] = { :ps => "foo" }
+    @node.automatic_attrs[:command] = { ps: "foo" }
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
 
@@ -65,13 +65,13 @@ describe "Chef::Provider::Service::Redhat" do
 
     describe "load current resource" do
       before do
-        status = double("Status", :exitstatus => 0, :stdout => "" , :stderr => "")
+        status = double("Status", exitstatus: 0, stdout: "" , stderr: "")
         allow(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
       end
 
       it "sets supports[:status] to true by default" do
-        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", :stderr => "")
-        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_return(chkconfig)
+        chkconfig = double("Chkconfig", exitstatus: 0, stdout: "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", stderr: "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_return(chkconfig)
         expect(@provider.service_missing).to be false
         @provider.load_current_resource
         expect(@provider.supports[:status]).to be true
@@ -80,9 +80,9 @@ describe "Chef::Provider::Service::Redhat" do
       it "lets the user override supports[:status] in the new_resource" do
         @new_resource.supports( { status: false } )
         @new_resource.pattern "myservice"
-        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", :stderr => "")
-        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_return(chkconfig)
-        foo_out = double("ps_command", :exitstatus => 0, :stdout => "a line that matches myservice", :stderr => "")
+        chkconfig = double("Chkconfig", exitstatus: 0, stdout: "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", stderr: "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_return(chkconfig)
+        foo_out = double("ps_command", exitstatus: 0, stdout: "a line that matches myservice", stderr: "")
         expect(@provider).to receive(:shell_out!).with("foo").and_return(foo_out)
         expect(@provider.service_missing).to be false
         expect(@provider).not_to receive(:shell_out).with("/sbin/service chef status")
@@ -91,16 +91,16 @@ describe "Chef::Provider::Service::Redhat" do
       end
 
       it "sets the current enabled status to true if the service is enabled for any run level" do
-        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", :stderr => "")
-        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_return(chkconfig)
+        chkconfig = double("Chkconfig", exitstatus: 0, stdout: "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", stderr: "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_return(chkconfig)
         expect(@provider.service_missing).to be false
         @provider.load_current_resource
         expect(@current_resource.enabled).to be true
       end
 
       it "sets the current enabled status to false if the regex does not match" do
-        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:off   6:off", :stderr => "")
-        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_return(chkconfig)
+        chkconfig = double("Chkconfig", exitstatus: 0, stdout: "chef    0:off   1:off   2:off   3:off   4:off   5:off   6:off", stderr: "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_return(chkconfig)
         expect(@provider.service_missing).to be false
         expect(@provider.load_current_resource).to eql(@current_resource)
         expect(@current_resource.enabled).to be false
@@ -108,8 +108,8 @@ describe "Chef::Provider::Service::Redhat" do
 
       it "sets the current enabled status to true if the service is enabled at specified run levels" do
         @new_resource.run_levels([1, 2])
-        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:on   2:on   3:off   4:off   5:off   6:off", :stderr => "")
-        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_return(chkconfig)
+        chkconfig = double("Chkconfig", exitstatus: 0, stdout: "chef    0:off   1:on   2:on   3:off   4:off   5:off   6:off", stderr: "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_return(chkconfig)
         expect(@provider.service_missing).to be false
         @provider.load_current_resource
         expect(@current_resource.enabled).to be true
@@ -118,8 +118,8 @@ describe "Chef::Provider::Service::Redhat" do
 
       it "sets the current enabled status to false if the service is enabled at a run level it should not" do
         @new_resource.run_levels([1, 2])
-        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:on   2:on   3:on   4:off   5:off   6:off", :stderr => "")
-        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_return(chkconfig)
+        chkconfig = double("Chkconfig", exitstatus: 0, stdout: "chef    0:off   1:on   2:on   3:on   4:off   5:off   6:off", stderr: "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_return(chkconfig)
         expect(@provider.service_missing).to be false
         @provider.load_current_resource
         expect(@current_resource.enabled).to be false
@@ -128,8 +128,8 @@ describe "Chef::Provider::Service::Redhat" do
 
       it "sets the current enabled status to false if the service is not enabled at specified run levels" do
         @new_resource.run_levels([ 2 ])
-        chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:on   2:off   3:off   4:off   5:off   6:off", :stderr => "")
-        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_return(chkconfig)
+        chkconfig = double("Chkconfig", exitstatus: 0, stdout: "chef    0:off   1:on   2:off   3:off   4:off   5:off   6:off", stderr: "")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_return(chkconfig)
         expect(@provider.service_missing).to be false
         @provider.load_current_resource
         expect(@current_resource.enabled).to be false
@@ -142,10 +142,10 @@ describe "Chef::Provider::Service::Redhat" do
 
       context "when the service does not exist" do
         before do
-          status = double("Status", :exitstatus => 1, :stdout => "", :stderr => "chef: unrecognized service")
+          status = double("Status", exitstatus: 1, stdout: "", stderr: "chef: unrecognized service")
           expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
-          chkconfig = double("Chkconfig", :existatus => 1, :stdout => "", :stderr => "error reading information on service chef: No such file or directory")
-          expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_return(chkconfig)
+          chkconfig = double("Chkconfig", existatus: 1, stdout: "", stderr: "error reading information on service chef: No such file or directory")
+          expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_return(chkconfig)
           @provider.load_current_resource
           @provider.define_resource_requirements
         end
@@ -194,10 +194,10 @@ describe "Chef::Provider::Service::Redhat" do
       it_should_behave_like "define_resource_requirements_common"
 
       it "should not raise an error if the service does not exist" do
-        status = double("Status", :exitstatus => 1, :stdout => "", :stderr => "chef: unrecognized service")
+        status = double("Status", exitstatus: 1, stdout: "", stderr: "chef: unrecognized service")
         expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
-        chkconfig = double("Chkconfig", :existatus => 1, :stdout => "", :stderr => "error reading information on service chef: No such file or directory")
-        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0, 1]).and_return(chkconfig)
+        chkconfig = double("Chkconfig", existatus: 1, stdout: "", stderr: "error reading information on service chef: No such file or directory")
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_return(chkconfig)
         @provider.load_current_resource
         @provider.define_resource_requirements
         expect { @provider.process_resource_requirements }.not_to raise_error