chef 14.2.0 → 14.3.37

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

@@ -21,7 +21,7 @@ require "spec_helper"
 describe Chef::Provider::Service::Simple, "load_current_resource" do
   before(:each) do
     @node = Chef::Node.new
-    @node.automatic_attrs[:command] = { :ps => "ps -ef" }
+    @node.automatic_attrs[:command] = { ps: "ps -ef" }
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
 
@@ -31,12 +31,12 @@ describe Chef::Provider::Service::Simple, "load_current_resource" do
     @provider = Chef::Provider::Service::Simple.new(@new_resource, @run_context)
     allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
 
-    @stdout = StringIO.new(<<-NOMOCKINGSTRINGSPLZ)
-aj        7842  5057  0 21:26 pts/2    00:00:06 vi init.rb
-aj        7903  5016  0 21:26 pts/5    00:00:00 /bin/bash
-aj        8119  6041  0 21:34 pts/3    00:00:03 vi simple_service_spec.rb
+    @stdout = StringIO.new(<<~NOMOCKINGSTRINGSPLZ)
+      aj        7842  5057  0 21:26 pts/2    00:00:06 vi init.rb
+      aj        7903  5016  0 21:26 pts/5    00:00:00 /bin/bash
+      aj        8119  6041  0 21:34 pts/3    00:00:03 vi simple_service_spec.rb
 NOMOCKINGSTRINGSPLZ
-    @status = double("Status", :exitstatus => 0, :stdout => @stdout)
+    @status = double("Status", exitstatus: 0, stdout: @stdout)
     allow(@provider).to receive(:shell_out!).and_return(@status)
   end
 
@@ -51,13 +51,13 @@ NOMOCKINGSTRINGSPLZ
   end
 
   it "should raise error if the node has a nil ps attribute and no other means to get status" do
-    @node.automatic_attrs[:command] = { :ps => nil }
+    @node.automatic_attrs[:command] = { ps: nil }
     @provider.define_resource_requirements
     expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
   end
 
   it "should raise error if the node has an empty ps attribute and no other means to get status" do
-    @node.automatic_attrs[:command] = { :ps => "" }
+    @node.automatic_attrs[:command] = { ps: "" }
     @provider.define_resource_requirements
     expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
   end
@@ -75,11 +75,11 @@ NOMOCKINGSTRINGSPLZ
     end
 
     it "should set running to true if the regex matches the output" do
-      @stdout = StringIO.new(<<-NOMOCKINGSTRINGSPLZ)
-aj        7842  5057  0 21:26 pts/2    00:00:06 chef
-aj        7842  5057  0 21:26 pts/2    00:00:06 poos
+      @stdout = StringIO.new(<<~NOMOCKINGSTRINGSPLZ)
+        aj        7842  5057  0 21:26 pts/2    00:00:06 chef
+        aj        7842  5057  0 21:26 pts/2    00:00:06 poos
 NOMOCKINGSTRINGSPLZ
-      @status = double("Status", :exitstatus => 0, :stdout => @stdout)
+      @status = double("Status", exitstatus: 0, stdout: @stdout)
       allow(@provider).to receive(:shell_out!).and_return(@status)
       @provider.load_current_resource
       expect(@current_resource.running).to be_truthy
@@ -106,8 +106,8 @@ NOMOCKINGSTRINGSPLZ
 
   describe "when starting the service" do
     it "should call the start command if one is specified" do
-      @new_resource.start_command("#{@new_resource.start_command}")
-      expect(@provider).to receive(:shell_out!).with("#{@new_resource.start_command}", default_env: false)
+      @new_resource.start_command((@new_resource.start_command).to_s)
+      expect(@provider).to receive(:shell_out!).with((@new_resource.start_command).to_s, default_env: false)
       @provider.start_service()
     end
 

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

@@ -74,19 +74,19 @@ describe Chef::Provider::Service::Solaris do
     ].join("\n")
 
     # shell_out! return value for a service that is running
-    @enabled_svc_status = double("Status", :exitstatus => 0, :stdout => enabled_svc_stdout, :stdin => "", :stderr => "")
+    @enabled_svc_status = double("Status", exitstatus: 0, stdout: enabled_svc_stdout, stdin: "", stderr: "")
 
     # shell_out! return value for a service that is disabled
-    @disabled_svc_status = double("Status", :exitstatus => 0, :stdout => disabled_svc_stdout, :stdin => "", :stderr => "")
+    @disabled_svc_status = double("Status", exitstatus: 0, stdout: disabled_svc_stdout, stdin: "", stderr: "")
 
     # shell_out! return value for a service that is in maintenance mode
-    @maintenance_svc_status = double("Status", :exitstatus => 0, :stdout => maintenance_svc_stdout, :stdin => "", :stderr => "")
+    @maintenance_svc_status = double("Status", exitstatus: 0, stdout: maintenance_svc_stdout, stdin: "", stderr: "")
 
     # shell_out! return value for a service that does not exist
-    @no_svc_status = double("Status", :exitstatus => 1, :stdout => "", :stdin => "", :stderr => "svcs: Pattern 'chef' doesn't match any instances\n")
+    @no_svc_status = double("Status", exitstatus: 1, stdout: "", stdin: "", stderr: "svcs: Pattern 'chef' doesn't match any instances\n")
 
     # shell_out! return value for a successful execution
-    @success = double("clear", :exitstatus => 0, :stdout => "", :stdin => "", :stderr => "")
+    @success = double("clear", exitstatus: 0, stdout: "", stdin: "", stderr: "")
   end
 
   it "should raise an error if /bin/svcs and /usr/sbin/svcadm are not executable" do
@@ -116,19 +116,19 @@ describe Chef::Provider::Service::Solaris do
 
     describe "when discovering the current service state" do
       it "should create a current resource with the name of the new resource" do
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@enabled_svc_status)
         expect(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
         expect(@provider.maintenance).to be_falsey
         @provider.load_current_resource
       end
 
       it "should return the current resource" do
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@enabled_svc_status)
         expect(@provider.load_current_resource).to eql(@current_resource)
       end
 
       it "should call '/bin/svcs -l service_name'" do
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@enabled_svc_status)
         @provider.load_current_resource
       end
 
@@ -163,7 +163,7 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call svcadm enable -s chef" do
-        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@enabled_svc_status)
         expect(@provider).not_to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", @current_resource.service_name).and_return(@success)
         @provider.load_current_resource
@@ -173,7 +173,7 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call svcadm enable -s chef for start_service" do
-        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@enabled_svc_status)
         expect(@provider).not_to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", @current_resource.service_name).and_return(@success)
         @provider.load_current_resource
@@ -183,7 +183,7 @@ describe Chef::Provider::Service::Solaris do
 
       it "should call svcadm clear chef for start_service when state maintenance" do
         # we are in maint mode
-        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@maintenance_svc_status)
+        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@maintenance_svc_status)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name).and_return(@success)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", @current_resource.service_name).and_return(@success)
 
@@ -192,7 +192,7 @@ describe Chef::Provider::Service::Solaris do
         expect(@provider.enable_service).to be_truthy
 
         # now we are enabled
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@enabled_svc_status)
         @provider.load_current_resource
 
         expect(@current_resource.enabled).to be_truthy
@@ -206,7 +206,7 @@ describe Chef::Provider::Service::Solaris do
 
       it "should call svcadm enable -s -r chef" do
         @new_resource.options("-r")
-        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@enabled_svc_status)
         expect(@provider).not_to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", "-r", @current_resource.service_name).and_return(@success)
         @provider.load_current_resource
@@ -216,7 +216,7 @@ describe Chef::Provider::Service::Solaris do
 
       it "should call svcadm enable -s -r -t chef when passed an array of options" do
         @new_resource.options(["-r", "-t"])
-        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@enabled_svc_status)
         expect(@provider).not_to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", "-r", "-t", @current_resource.service_name).and_return(@success)
         @provider.load_current_resource
@@ -232,7 +232,7 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call svcadm disable -s chef" do
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@disabled_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@disabled_svc_status)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "disable", "-s", "chef").and_return(@success)
         @provider.load_current_resource
         expect(@provider.disable_service).to be_truthy
@@ -240,7 +240,7 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call svcadm disable -s chef for stop_service" do
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@disabled_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@disabled_svc_status)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "disable", "-s", "chef").and_return(@success)
         @provider.load_current_resource
         expect(@provider.disable_service).to be_truthy
@@ -249,7 +249,7 @@ describe Chef::Provider::Service::Solaris do
 
       it "should call svcadm disable chef with options" do
         @new_resource.options("-t")
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@disabled_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@disabled_svc_status)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "disable", "-s", "-t", "chef").and_return(@success)
         @provider.load_current_resource
         expect(@provider.disable_service).to be_truthy
@@ -261,7 +261,7 @@ describe Chef::Provider::Service::Solaris do
     describe "when reloading the service" do
       before(:each) do
         @provider.current_resource = @current_resource
-        allow(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        allow(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@enabled_svc_status)
       end
 
       it "should call svcadm refresh chef" do
@@ -274,7 +274,7 @@ describe Chef::Provider::Service::Solaris do
     describe "when the service doesn't exist" do
       before(:each) do
         @provider.current_resource = @current_resource
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@no_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { returns: [0, 1] }).and_return(@no_svc_status)
       end
 
       it "should be marked not running" do

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

@@ -36,11 +36,11 @@ describe Chef::Provider::Service::Systemd do
   let(:provider) { Chef::Provider::Service::Systemd.new(new_resource, run_context) }
 
   let(:shell_out_success) do
-    double("shell_out", :exitstatus => 0, :error? => false)
+    double("shell_out", exitstatus: 0, error?: false)
   end
 
   let(:shell_out_failure) do
-    double("shell_out", :exitstatus => 1, :error? => true)
+    double("shell_out", exitstatus: 1, error?: true)
   end
 
   let(:current_resource) { Chef::Resource::Service.new(service_name) }
@@ -190,14 +190,14 @@ describe Chef::Provider::Service::Systemd do
         context "when a user is specified" do
           it "should call '#{systemctl_path} --user start service_name' if no start command is specified" do
             current_resource.user("joe")
-            expect(provider).to receive(:shell_out!).with("#{systemctl_path} --user start #{service_name_escaped}", { :environment => { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, :user => "joe", default_env: false }).and_return(shell_out_success)
+            expect(provider).to receive(:shell_out!).with("#{systemctl_path} --user start #{service_name_escaped}", { environment: { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, user: "joe", default_env: false }).and_return(shell_out_success)
             provider.start_service
           end
 
           it "should not call '#{systemctl_path} --user start service_name' if it is already running" do
             current_resource.running(true)
             current_resource.user("joe")
-            expect(provider).not_to receive(:shell_out!).with("#{systemctl_path} --user start #{service_name_escaped}", { :environment => { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, :user => "joe" })
+            expect(provider).not_to receive(:shell_out!).with("#{systemctl_path} --user start #{service_name_escaped}", { environment: { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, user: "joe" })
             provider.start_service
           end
         end
@@ -264,7 +264,7 @@ describe Chef::Provider::Service::Systemd do
         before(:each) do
           provider.current_resource = current_resource
           current_resource.service_name(service_name)
-          allow(provider).to receive(:which).with("systemctl").and_return("#{systemctl_path}")
+          allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
         it "should call '#{systemctl_path} --system enable service_name' to enable the service" do
@@ -282,7 +282,7 @@ describe Chef::Provider::Service::Systemd do
         before(:each) do
           provider.current_resource = current_resource
           current_resource.service_name(service_name)
-          allow(provider).to receive(:which).with("systemctl").and_return("#{systemctl_path}")
+          allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
         it "should call '#{systemctl_path} --system mask service_name' to mask the service" do
@@ -300,7 +300,7 @@ describe Chef::Provider::Service::Systemd do
         before(:each) do
           provider.current_resource = current_resource
           current_resource.service_name(service_name)
-          allow(provider).to receive(:which).with("systemctl").and_return("#{systemctl_path}")
+          allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
         it "should return true if '#{systemctl_path} --system is-active service_name' returns 0" do
@@ -318,7 +318,7 @@ describe Chef::Provider::Service::Systemd do
         before(:each) do
           provider.current_resource = current_resource
           current_resource.service_name(service_name)
-          allow(provider).to receive(:which).with("systemctl").and_return("#{systemctl_path}")
+          allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
         it "should return true if '#{systemctl_path} --system is-enabled service_name' returns 0" do
@@ -336,26 +336,26 @@ describe Chef::Provider::Service::Systemd do
         before(:each) do
           provider.current_resource = current_resource
           current_resource.service_name(service_name)
-          allow(provider).to receive(:which).with("systemctl").and_return("#{systemctl_path}")
+          allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
         it "should return true if '#{systemctl_path} --system is-enabled service_name' returns 'masked' and returns anything except 0" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(:stdout => "masked", :exitstatus => shell_out_failure))
+          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "masked", exitstatus: shell_out_failure))
           expect(provider.is_masked?).to be true
         end
 
         it "should return true if '#{systemctl_path} --system is-enabled service_name' outputs 'masked-runtime' and returns anything except 0" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(:stdout => "masked-runtime", :exitstatus => shell_out_failure))
+          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "masked-runtime", exitstatus: shell_out_failure))
           expect(provider.is_masked?).to be true
         end
 
         it "should return false if '#{systemctl_path} --system is-enabled service_name' returns 0" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(:stdout => "enabled", :exitstatus => shell_out_success))
+          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "enabled", exitstatus: shell_out_success))
           expect(provider.is_masked?).to be false
         end
 
         it "should return false if '#{systemctl_path} --system is-enabled service_name' returns anything except 0 and outputs an error'" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(:stdout => "Failed to get unit file state for #{service_name}: No such file or directory", :exitstatus => shell_out_failure))
+          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "Failed to get unit file state for #{service_name}: No such file or directory", exitstatus: shell_out_failure))
           expect(provider.is_masked?).to be false
         end
       end

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

@@ -20,7 +20,7 @@ require "spec_helper"
 
 describe Chef::Provider::Service::Upstart do
   let(:shell_out_success) do
-    double("shell_out", :exitstatus => 0, :error? => false)
+    double("shell_out", exitstatus: 0, error?: false)
   end
 
   before(:each) do
@@ -43,7 +43,7 @@ describe Chef::Provider::Service::Upstart do
 
     it "should return /etc/event.d as the upstart job directory when running on Ubuntu 9.04" do
       @node.automatic_attrs[:platform_version] = "9.04"
-      #Chef::Platform.stub(:find_platform_and_version).and_return([ "ubuntu", "9.04" ])
+      # Chef::Platform.stub(:find_platform_and_version).and_return([ "ubuntu", "9.04" ])
       @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
       expect(@provider.instance_variable_get(:@upstart_job_dir)).to eq("/etc/event.d")
       expect(@provider.instance_variable_get(:@upstart_conf_suffix)).to eq("")
@@ -66,7 +66,7 @@ describe Chef::Provider::Service::Upstart do
 
   describe "load_current_resource" do
     before(:each) do
-      @node.automatic_attrs[:command] = { :ps => "ps -ax" }
+      @node.automatic_attrs[:command] = { ps: "ps -ax" }
 
       @current_resource = Chef::Resource::Service.new("rsyslog")
       allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
@@ -167,14 +167,14 @@ describe Chef::Provider::Service::Upstart do
     end
 
     it "should set enabled to true when it finds 'starts on'" do
-      @lines = double("start on filesystem", :gets => "start on filesystem")
+      @lines = double("start on filesystem", gets: "start on filesystem")
       allow(::File).to receive(:open).and_yield(@lines)
       expect(@current_resource).to receive(:running).with(false)
       @provider.load_current_resource
     end
 
     it "should set enabled to false when it finds '#starts on'" do
-      @lines = double("start on filesystem", :gets => "#start on filesystem")
+      @lines = double("start on filesystem", gets: "#start on filesystem")
       allow(::File).to receive(:open).and_yield(@lines)
       expect(@current_resource).to receive(:running).with(false)
       @provider.load_current_resource

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

@@ -98,7 +98,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
     Win32::Service::DISABLED = 0x00000004
 
     allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-      double("StatusStruct", :current_state => "running"))
+      double("StatusStruct", current_state: "running"))
     allow(Win32::Service).to receive(:config_info).with(new_resource.service_name)
       .and_return(chef_service_config_info)
 
@@ -502,13 +502,13 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
   describe Chef::Provider::Service::Windows, "start_service" do
     before(:each) do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "stopped"),
-        double("StatusStruct", :current_state => "running"))
+        double("StatusStruct", current_state: "stopped"),
+        double("StatusStruct", current_state: "running"))
     end
 
     it "calls the start command if one is specified" do
       new_resource.start_command "sc start #{chef_service_name}"
-      expect(provider).to receive(:shell_out!).with("#{new_resource.start_command}").and_return("Starting custom service")
+      expect(provider).to receive(:shell_out!).with((new_resource.start_command).to_s).and_return("Starting custom service")
       provider.start_service
       expect(new_resource.updated_by_last_action?).to be_truthy
     end
@@ -528,7 +528,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "does nothing if the service is running" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "running"))
+        double("StatusStruct", current_state: "running"))
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
       provider.start_service
@@ -537,7 +537,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "raises an error if the service is paused" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "paused"))
+        double("StatusStruct", current_state: "paused"))
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
       expect { provider.start_service }.to raise_error( Chef::Exceptions::Service )
@@ -546,9 +546,9 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "waits and continues if the service is in start_pending" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "start pending"),
-        double("StatusStruct", :current_state => "start pending"),
-        double("StatusStruct", :current_state => "running"))
+        double("StatusStruct", current_state: "start pending"),
+        double("StatusStruct", current_state: "start pending"),
+        double("StatusStruct", current_state: "running"))
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
       provider.start_service
@@ -557,7 +557,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "fails if the service is in stop_pending" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "stop pending"))
+        double("StatusStruct", current_state: "stop pending"))
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
       expect { provider.start_service }.to raise_error( Chef::Exceptions::Service )
@@ -597,13 +597,13 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     before(:each) do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "running"),
-        double("StatusStruct", :current_state => "stopped"))
+        double("StatusStruct", current_state: "running"),
+        double("StatusStruct", current_state: "stopped"))
     end
 
     it "calls the stop command if one is specified" do
       new_resource.stop_command "sc stop #{chef_service_name}"
-      expect(provider).to receive(:shell_out!).with("#{new_resource.stop_command}").and_return("Stopping custom service")
+      expect(provider).to receive(:shell_out!).with((new_resource.stop_command).to_s).and_return("Stopping custom service")
       provider.stop_service
       expect(new_resource.updated_by_last_action?).to be_truthy
     end
@@ -623,7 +623,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "does nothing if the service is stopped" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "stopped"))
+        double("StatusStruct", current_state: "stopped"))
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
       provider.stop_service
@@ -632,7 +632,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "raises an error if the service is paused" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "paused"))
+        double("StatusStruct", current_state: "paused"))
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
       expect { provider.stop_service }.to raise_error( Chef::Exceptions::Service )
@@ -641,9 +641,9 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "waits and continue if the service is in stop_pending" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "stop pending"),
-        double("StatusStruct", :current_state => "stop pending"),
-        double("StatusStruct", :current_state => "stopped"))
+        double("StatusStruct", current_state: "stop pending"),
+        double("StatusStruct", current_state: "stop pending"),
+        double("StatusStruct", current_state: "stopped"))
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
       provider.stop_service
@@ -652,7 +652,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "fails if the service is in start_pending" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "start pending"))
+        double("StatusStruct", current_state: "start pending"))
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
       expect { provider.stop_service }.to raise_error( Chef::Exceptions::Service )
@@ -661,7 +661,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "passes custom timeout to the stop command if provided" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "running"))
+        double("StatusStruct", current_state: "running"))
       new_resource.timeout 1
       expect(Win32::Service).to receive(:stop).with(new_resource.service_name)
       Timeout.timeout(2) do
@@ -676,17 +676,17 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "calls the restart command if one is specified" do
       new_resource.restart_command "sc restart"
-      expect(provider).to receive(:shell_out!).with("#{new_resource.restart_command}")
+      expect(provider).to receive(:shell_out!).with((new_resource.restart_command).to_s)
       provider.restart_service
       expect(new_resource.updated_by_last_action?).to be_truthy
     end
 
     it "stops then starts the service if it is running" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "running"),
-        double("StatusStruct", :current_state => "stopped"),
-        double("StatusStruct", :current_state => "stopped"),
-        double("StatusStruct", :current_state => "running"))
+        double("StatusStruct", current_state: "running"),
+        double("StatusStruct", current_state: "stopped"),
+        double("StatusStruct", current_state: "stopped"),
+        double("StatusStruct", current_state: "running"))
       expect(Win32::Service).to receive(:stop).with(new_resource.service_name)
       expect(Win32::Service).to receive(:start).with(new_resource.service_name)
       provider.restart_service
@@ -695,9 +695,9 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "just starts the service if it is stopped" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", :current_state => "stopped"),
-        double("StatusStruct", :current_state => "stopped"),
-        double("StatusStruct", :current_state => "running"))
+        double("StatusStruct", current_state: "stopped"),
+        double("StatusStruct", current_state: "stopped"),
+        double("StatusStruct", current_state: "running"))
       expect(Win32::Service).to receive(:start).with(new_resource.service_name)
       provider.restart_service
       expect(new_resource.updated_by_last_action?).to be_truthy
@@ -716,11 +716,11 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
   describe Chef::Provider::Service::Windows, "enable_service" do
     before(:each) do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", :start_type => "disabled"))
+        double("ConfigStruct", start_type: "disabled"))
     end
 
     it "enables service" do
-      expect(Win32::Service).to receive(:configure).with(:service_name => new_resource.service_name, :start_type => Win32::Service::AUTO_START)
+      expect(Win32::Service).to receive(:configure).with(service_name: new_resource.service_name, start_type: Win32::Service::AUTO_START)
       provider.enable_service
       expect(new_resource.updated_by_last_action?).to be_truthy
     end
@@ -736,14 +736,14 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
   describe Chef::Provider::Service::Windows, "action_enable" do
     it "does nothing if the service is enabled" do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", :start_type => "auto start"))
+        double("ConfigStruct", start_type: "auto start"))
       expect(provider).not_to receive(:enable_service)
       provider.action_enable
     end
 
     it "enables the service if it is not set to automatic start" do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", :start_type => "disabled"))
+        double("ConfigStruct", start_type: "disabled"))
       expect(provider).to receive(:enable_service)
       provider.action_enable
     end
@@ -752,14 +752,14 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
   describe Chef::Provider::Service::Windows, "action_disable" do
     it "does nothing if the service is disabled" do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", :start_type => "disabled"))
+        double("ConfigStruct", start_type: "disabled"))
       expect(provider).not_to receive(:disable_service)
       provider.action_disable
     end
 
     it "disables the service if it is not set to disabled" do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", :start_type => "auto start"))
+        double("ConfigStruct", start_type: "auto start"))
       expect(provider).to receive(:disable_service)
       provider.action_disable
     end
@@ -768,7 +768,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
   describe Chef::Provider::Service::Windows, "disable_service" do
     before(:each) do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", :start_type => "auto start"))
+        double("ConfigStruct", start_type: "auto start"))
     end
 
     it "disables service" do
@@ -810,17 +810,17 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
   describe Chef::Provider::Service::Windows, "set_start_type" do
     it "when called with :automatic it calls Win32::Service#configure with Win32::Service::AUTO_START" do
-      expect(Win32::Service).to receive(:configure).with(:service_name => new_resource.service_name, :start_type => Win32::Service::AUTO_START)
+      expect(Win32::Service).to receive(:configure).with(service_name: new_resource.service_name, start_type: Win32::Service::AUTO_START)
       provider.send(:set_startup_type, :automatic)
     end
 
     it "when called with :manual it calls Win32::Service#configure with Win32::Service::DEMAND_START" do
-      expect(Win32::Service).to receive(:configure).with(:service_name => new_resource.service_name, :start_type => Win32::Service::DEMAND_START)
+      expect(Win32::Service).to receive(:configure).with(service_name: new_resource.service_name, start_type: Win32::Service::DEMAND_START)
       provider.send(:set_startup_type, :manual)
     end
 
     it "when called with :disabled it calls Win32::Service#configure with Win32::Service::DISABLED" do
-      expect(Win32::Service).to receive(:configure).with(:service_name => new_resource.service_name, :start_type => Win32::Service::DISABLED)
+      expect(Win32::Service).to receive(:configure).with(service_name: new_resource.service_name, start_type: Win32::Service::DISABLED)
       provider.send(:set_startup_type, :disabled)
     end