chef 11.10.0.rc.0-x86-mingw32 → 11.10.0.rc.1-x86-mingw32

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

@@ -30,10 +30,10 @@ describe Chef::Provider::Service::Systemd do
   describe "load_current_resource" do
     before(:each) do
       @current_resource = Chef::Resource::Service.new('rsyslog.service')
-      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      Chef::Resource::Service.stub(:new).and_return(@current_resource)
 
-      @provider.stub!(:is_active?).and_return(false)
-      @provider.stub!(:is_enabled?).and_return(false)
+      @provider.stub(:is_active?).and_return(false)
+      @provider.stub(:is_enabled?).and_return(false)
     end
 
     it "should create a current resource with the name of the new resource" do
@@ -52,42 +52,42 @@ describe Chef::Provider::Service::Systemd do
     end
 
     it "should set running to true if the service is running" do
-      @provider.stub!(:is_active?).and_return(true)
+      @provider.stub(:is_active?).and_return(true)
       @current_resource.should_receive(:running).with(true)
       @provider.load_current_resource
     end
 
     it "should set running to false if the service is not running" do
-      @provider.stub!(:is_active?).and_return(false)
+      @provider.stub(:is_active?).and_return(false)
       @current_resource.should_receive(:running).with(false)
       @provider.load_current_resource
     end
 
     describe "when a status command has been specified" do
       before do
-        @new_resource.stub!(:status_command).and_return("/bin/chefhasmonkeypants status")
+        @new_resource.stub(:status_command).and_return("/bin/chefhasmonkeypants status")
       end
 
       it "should run the services status command if one has been specified" do
-        @provider.stub!(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
+        @provider.stub(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
         @current_resource.should_receive(:running).with(true)
         @provider.load_current_resource
       end
 
       it "should run the services status command if one has been specified and properly set status check state" do
-        @provider.stub!(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
+        @provider.stub(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
         @provider.load_current_resource
         @provider.instance_variable_get("@status_check_success").should be_true
       end
 
       it "should set running to false if it catches a Chef::Exceptions::Exec when using a status command" do
-        @provider.stub!(:run_command_with_systems_locale).and_raise(Chef::Exceptions::Exec)
+        @provider.stub(:run_command_with_systems_locale).and_raise(Chef::Exceptions::Exec)
         @current_resource.should_receive(:running).with(false)
         @provider.load_current_resource
       end
 
       it "should update state to indicate status check failed when an exception is thrown using a status command" do
-        @provider.stub!(:run_command_with_systems_locale).and_raise(Chef::Exceptions::Exec)
+        @provider.stub(:run_command_with_systems_locale).and_raise(Chef::Exceptions::Exec)
         @provider.load_current_resource
         @provider.instance_variable_get("@status_check_success").should be_false
       end
@@ -99,13 +99,13 @@ describe Chef::Provider::Service::Systemd do
     end
 
     it "should set enabled to true if the service is enabled" do
-      @provider.stub!(:is_enabled?).and_return(true)
+      @provider.stub(:is_enabled?).and_return(true)
       @current_resource.should_receive(:enabled).with(true)
       @provider.load_current_resource
     end
 
     it "should set enabled to false if the service is not enabled" do
-      @provider.stub!(:is_enabled?).and_return(false)
+      @provider.stub(:is_enabled?).and_return(false)
       @current_resource.should_receive(:enabled).with(false)
       @provider.load_current_resource
     end
@@ -118,12 +118,12 @@ describe Chef::Provider::Service::Systemd do
   describe "start and stop service" do
     before(:each) do
       @current_resource = Chef::Resource::Service.new('rsyslog.service')
-      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      Chef::Resource::Service.stub(:new).and_return(@current_resource)
       @provider.current_resource = @current_resource
     end
 
     it "should call the start command if one is specified" do
-      @new_resource.stub!(:start_command).and_return("/sbin/rsyslog startyousillysally")
+      @new_resource.stub(:start_command).and_return("/sbin/rsyslog startyousillysally")
       @provider.should_receive(:shell_out!).with("/sbin/rsyslog startyousillysally")
       @provider.start_service
     end
@@ -134,52 +134,52 @@ describe Chef::Provider::Service::Systemd do
     end
 
     it "should not call '/bin/systemctl start service_name' if it is already running" do
-      @current_resource.stub!(:running).and_return(true)
+      @current_resource.stub(:running).and_return(true)
       @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl start #{@new_resource.service_name}"})
       @provider.start_service
     end
 
     it "should call the restart command if one is specified" do
-      @current_resource.stub!(:running).and_return(true)
-      @new_resource.stub!(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
+      @current_resource.stub(:running).and_return(true)
+      @new_resource.stub(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
       @provider.should_receive(:shell_out!).with("/sbin/rsyslog restartyousillysally")
       @provider.restart_service
     end
 
     it "should call '/bin/systemctl restart service_name' if no restart command is specified" do
-      @current_resource.stub!(:running).and_return(true)
+      @current_resource.stub(:running).and_return(true)
       @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl restart #{@new_resource.service_name}"}).and_return(0)
       @provider.restart_service
     end
 
     it "should call the reload command if one is specified" do
-      @current_resource.stub!(:running).and_return(true)
-      @new_resource.stub!(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
+      @current_resource.stub(:running).and_return(true)
+      @new_resource.stub(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
       @provider.should_receive(:shell_out!).with("/sbin/rsyslog reloadyousillysally")
       @provider.reload_service
     end
 
     it "should call '/bin/systemctl reload service_name' if no reload command is specified" do
-      @current_resource.stub!(:running).and_return(true)
+      @current_resource.stub(:running).and_return(true)
       @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl reload #{@new_resource.service_name}"}).and_return(0)
       @provider.reload_service
     end
 
     it "should call the stop command if one is specified" do
-      @current_resource.stub!(:running).and_return(true)
-      @new_resource.stub!(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
+      @current_resource.stub(:running).and_return(true)
+      @new_resource.stub(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
       @provider.should_receive(:shell_out!).with("/sbin/rsyslog stopyousillysally")
       @provider.stop_service
     end
 
     it "should call '/bin/systemctl stop service_name' if no stop command is specified" do
-      @current_resource.stub!(:running).and_return(true)
+      @current_resource.stub(:running).and_return(true)
       @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl stop #{@new_resource.service_name}"}).and_return(0)
       @provider.stop_service
     end
 
     it "should not call '/bin/systemctl stop service_name' if it is already stopped" do
-      @current_resource.stub!(:running).and_return(false)
+      @current_resource.stub(:running).and_return(false)
       @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl stop #{@new_resource.service_name}"})
       @provider.stop_service
     end
@@ -188,7 +188,7 @@ describe Chef::Provider::Service::Systemd do
   describe "enable and disable service" do
     before(:each) do
       @current_resource = Chef::Resource::Service.new('rsyslog.service')
-      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      Chef::Resource::Service.stub(:new).and_return(@current_resource)
       @provider.current_resource = @current_resource
     end
 
@@ -206,7 +206,7 @@ describe Chef::Provider::Service::Systemd do
   describe "is_active?" do
     before(:each) do
       @current_resource = Chef::Resource::Service.new('rsyslog.service')
-      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      Chef::Resource::Service.stub(:new).and_return(@current_resource)
     end
 
     it "should return true if '/bin/systemctl is-active service_name' returns 0" do
@@ -223,7 +223,7 @@ describe Chef::Provider::Service::Systemd do
   describe "is_enabled?" do
     before(:each) do
       @current_resource = Chef::Resource::Service.new('rsyslog.service')
-      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      Chef::Resource::Service.stub(:new).and_return(@current_resource)
     end
 
     it "should return true if '/bin/systemctl is-enabled service_name' returns 0" do

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

@@ -39,7 +39,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)
       @provider.instance_variable_get(:@upstart_job_dir).should == "/etc/event.d"
       @provider.instance_variable_get(:@upstart_conf_suffix).should == ""
@@ -65,17 +65,17 @@ describe Chef::Provider::Service::Upstart do
       @node.automatic_attrs[:command] = {:ps => "ps -ax"}
 
       @current_resource = Chef::Resource::Service.new("rsyslog")
-      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      Chef::Resource::Service.stub(:new).and_return(@current_resource)
 
-      @status = mock("Status", :exitstatus => 0)
-      @provider.stub!(:popen4).and_return(@status)
+      @status = double("Status", :exitstatus => 0)
+      @provider.stub(:popen4).and_return(@status)
       @stdin = StringIO.new
       @stdout = StringIO.new
       @stderr = StringIO.new
-      @pid = mock("PID")
+      @pid = double("PID")
 
-      ::File.stub!(:exists?).and_return(true)
-      ::File.stub!(:open).and_return(true)
+      ::File.stub(:exists?).and_return(true)
+      ::File.stub(:open).and_return(true)
     end
 
     it "should create a current resource with the name of the new resource" do
@@ -99,14 +99,14 @@ describe Chef::Provider::Service::Upstart do
 
       it "should set running to true if the status command returns 0" do
         @stdout = StringIO.new("rsyslog start/running")
-        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
         @current_resource.running.should be_true
       end
 
       it "should set running to false if the status command returns anything except 0" do
         @stdout = StringIO.new("rsyslog stop/waiting")
-        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
         @current_resource.running.should be_false
       end
@@ -115,41 +115,41 @@ describe Chef::Provider::Service::Upstart do
     describe "when the status command uses the old format" do
       it "should set running to true if the status command returns 0" do
         @stdout = StringIO.new("rsyslog (start) running, process 32225")
-        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
         @current_resource.running.should be_true
       end
 
       it "should set running to false if the status command returns anything except 0" do
         @stdout = StringIO.new("rsyslog (stop) waiting")
-        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
         @current_resource.running.should be_false
       end
     end
 
     it "should set running to false if it catches a Chef::Exceptions::Exec" do
-      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+      @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
       @current_resource.should_receive(:running).with(false)
       @provider.load_current_resource
     end
 
     it "should set enabled to true when it finds 'starts on'" do
-      @lines = mock("start on filesystem", :gets => "start on filesystem")
-      ::File.stub!(:open).and_yield(@lines)
+      @lines = double("start on filesystem", :gets => "start on filesystem")
+      ::File.stub(:open).and_yield(@lines)
       @current_resource.should_receive(:running).with(false)
       @provider.load_current_resource
     end
 
     it "should set enabled to false when it finds '#starts on'" do
-      @lines = mock("start on filesystem", :gets => "#start on filesystem")
-      ::File.stub!(:open).and_yield(@lines)
+      @lines = double("start on filesystem", :gets => "#start on filesystem")
+      ::File.stub(:open).and_yield(@lines)
       @current_resource.should_receive(:running).with(false)
       @provider.load_current_resource
     end
 
     it "should assume disable when no job configuration file is found" do
-      ::File.stub!(:exists?).and_return(false)
+      ::File.stub(:exists?).and_return(false)
       @current_resource.should_receive(:running).with(false)
       @provider.load_current_resource
     end
@@ -163,23 +163,23 @@ describe Chef::Provider::Service::Upstart do
 
     describe "when a status command has been specified" do
       before do
-        @new_resource.stub!(:status_command).and_return("/bin/chefhasmonkeypants status")
+        @new_resource.stub(:status_command).and_return("/bin/chefhasmonkeypants status")
       end
 
       it "should run the services status command if one has been specified" do
-        @provider.stub!(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
+        @provider.stub(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
         @current_resource.should_receive(:running).with(true)
         @provider.load_current_resource
       end
 
       it "should track state when the user-provided status command fails" do
-        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+        @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
         @provider.load_current_resource
         @provider.instance_variable_get("@command_success").should == false
       end
 
       it "should set running to false if it catches a Chef::Exceptions::Exec when using a status command" do
-        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+        @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
         @current_resource.should_receive(:running).with(false)
         @provider.load_current_resource
       end
@@ -201,15 +201,15 @@ describe Chef::Provider::Service::Upstart do
   describe "enable and disable service" do
     before(:each) do
       @current_resource = Chef::Resource::Service.new('rsyslog')
-      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      Chef::Resource::Service.stub(:new).and_return(@current_resource)
       @provider.current_resource = @current_resource
-      Chef::Util::FileEdit.stub!(:new)
+      Chef::Util::FileEdit.stub(:new)
     end
 
     it "should enable the service if it is not enabled" do
       @file = Object.new
-      Chef::Util::FileEdit.stub!(:new).and_return(@file)
-      @current_resource.stub!(:enabled).and_return(false)
+      Chef::Util::FileEdit.stub(:new).and_return(@file)
+      @current_resource.stub(:enabled).and_return(false)
       @file.should_receive(:search_file_replace)
       @file.should_receive(:write_file)
       @provider.enable_service()
@@ -217,8 +217,8 @@ describe Chef::Provider::Service::Upstart do
 
     it "should disable the service if it is enabled" do
       @file = Object.new
-      Chef::Util::FileEdit.stub!(:new).and_return(@file)
-      @current_resource.stub!(:enabled).and_return(true)
+      Chef::Util::FileEdit.stub(:new).and_return(@file)
+      @current_resource.stub(:enabled).and_return(true)
       @file.should_receive(:search_file_replace)
       @file.should_receive(:write_file)
       @provider.disable_service()
@@ -230,12 +230,12 @@ describe Chef::Provider::Service::Upstart do
     before(:each) do
       @current_resource = Chef::Resource::Service.new('rsyslog')
 
-      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      Chef::Resource::Service.stub(:new).and_return(@current_resource)
       @provider.current_resource = @current_resource
     end
 
     it "should call the start command if one is specified" do
-      @new_resource.stub!(:start_command).and_return("/sbin/rsyslog startyousillysally")
+      @new_resource.stub(:start_command).and_return("/sbin/rsyslog startyousillysally")
       @provider.should_receive(:shell_out!).with("/sbin/rsyslog startyousillysally")
       @provider.start_service()
     end
@@ -246,7 +246,7 @@ describe Chef::Provider::Service::Upstart do
     end
 
     it "should not call '/sbin/start service_name' if it is already running" do
-      @current_resource.stub!(:running).and_return(true)
+      @current_resource.stub(:running).and_return(true)
       @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"})
       @provider.start_service()
     end
@@ -261,52 +261,52 @@ describe Chef::Provider::Service::Upstart do
     end
 
     it "should call the restart command if one is specified" do
-      @current_resource.stub!(:running).and_return(true)
-      @new_resource.stub!(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
+      @current_resource.stub(:running).and_return(true)
+      @new_resource.stub(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
       @provider.should_receive(:shell_out!).with("/sbin/rsyslog restartyousillysally")
       @provider.restart_service()
     end
 
     it "should call '/sbin/restart service_name' if no restart command is specified" do
-      @current_resource.stub!(:running).and_return(true)
+      @current_resource.stub(:running).and_return(true)
       @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/restart #{@new_resource.service_name}"}).and_return(0)
       @provider.restart_service()
     end
 
     it "should call '/sbin/start service_name' if restart_service is called for a stopped service" do
-      @current_resource.stub!(:running).and_return(false)
+      @current_resource.stub(:running).and_return(false)
       @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"}).and_return(0)
       @provider.restart_service()
     end
 
     it "should call the reload command if one is specified" do
-      @current_resource.stub!(:running).and_return(true)
-      @new_resource.stub!(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
+      @current_resource.stub(:running).and_return(true)
+      @new_resource.stub(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
       @provider.should_receive(:shell_out!).with("/sbin/rsyslog reloadyousillysally")
       @provider.reload_service()
     end
 
     it "should call '/sbin/reload service_name' if no reload command is specified" do
-      @current_resource.stub!(:running).and_return(true)
+      @current_resource.stub(:running).and_return(true)
       @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/reload #{@new_resource.service_name}"}).and_return(0)
       @provider.reload_service()
     end
 
     it "should call the stop command if one is specified" do
-      @current_resource.stub!(:running).and_return(true)
-      @new_resource.stub!(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
+      @current_resource.stub(:running).and_return(true)
+      @new_resource.stub(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
       @provider.should_receive(:shell_out!).with("/sbin/rsyslog stopyousillysally")
       @provider.stop_service()
     end
 
     it "should call '/sbin/stop service_name' if no stop command is specified" do
-      @current_resource.stub!(:running).and_return(true)
+      @current_resource.stub(:running).and_return(true)
       @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/stop #{@new_resource.service_name}"}).and_return(0)
       @provider.stop_service()
     end
 
     it "should not call '/sbin/stop service_name' if it is already stopped" do
-      @current_resource.stub!(:running).and_return(false)
+      @current_resource.stub(:running).and_return(false)
       @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/sbin/stop #{@new_resource.service_name}"})
       @provider.stop_service()
     end

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

@@ -31,11 +31,11 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     Win32::Service = Class.new
     Win32::Service::AUTO_START = 0x00000002
     Win32::Service::DISABLED = 0x00000004
-    Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
-      mock("StatusStruct", :current_state => "running"))
-    Win32::Service.stub!(:config_info).with(@new_resource.service_name).and_return(
-      mock("ConfigStruct", :start_type => "auto start"))
-    Win32::Service.stub!(:exists?).and_return(true)
+    Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      double("StatusStruct", :current_state => "running"))
+    Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+      double("ConfigStruct", :start_type => "auto start"))
+    Win32::Service.stub(:exists?).and_return(true)
   end
 
   it "should set the current resources service name to the new resources service name" do
@@ -59,9 +59,9 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
 
   describe Chef::Provider::Service::Windows, "start_service" do
     before(:each) do
-      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
-        mock("StatusStruct", :current_state => "stopped"),
-        mock("StatusStruct", :current_state => "running"))
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "stopped"),
+        double("StatusStruct", :current_state => "running"))
     end
 
     it "should call the start command if one is specified" do
@@ -78,15 +78,15 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     end
 
     it "should do nothing if the service does not exist" do
-      Win32::Service.stub!(:exists?).with(@new_resource.service_name).and_return(false)
+      Win32::Service.stub(:exists?).with(@new_resource.service_name).and_return(false)
       Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
       @provider.start_service
       @new_resource.updated_by_last_action?.should be_false
     end
 
     it "should do nothing if the service is running" do
-      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
-        mock("StatusStruct", :current_state => "running"))
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "running"))
       @provider.load_current_resource
       Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
       @provider.start_service
@@ -97,9 +97,9 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
   describe Chef::Provider::Service::Windows, "stop_service" do
 
     before(:each) do
-      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
-        mock("StatusStruct", :current_state => "running"),
-        mock("StatusStruct", :current_state => "stopped"))
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "running"),
+        double("StatusStruct", :current_state => "stopped"))
     end
 
     it "should call the stop command if one is specified" do
@@ -116,15 +116,15 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     end
 
     it "should do nothing if the service does not exist" do
-      Win32::Service.stub!(:exists?).with(@new_resource.service_name).and_return(false)
+      Win32::Service.stub(:exists?).with(@new_resource.service_name).and_return(false)
       Win32::Service.should_not_receive(:stop).with(@new_resource.service_name)
       @provider.stop_service
       @new_resource.updated_by_last_action?.should be_false
     end
 
     it "should do nothing if the service is stopped" do
-      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
-        mock("StatusStruct", :current_state => "stopped"))
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "stopped"))
       @provider.load_current_resource
       Win32::Service.should_not_receive(:stop).with(@new_resource.service_name)
       @provider.stop_service
@@ -142,11 +142,11 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     end
 
     it "should stop then start the service if it is running" do
-      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
-        mock("StatusStruct", :current_state => "running"),
-        mock("StatusStruct", :current_state => "stopped"),
-        mock("StatusStruct", :current_state => "stopped"),
-        mock("StatusStruct", :current_state => "running"))
+      Win32::Service.stub(: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"))
       Win32::Service.should_receive(:stop).with(@new_resource.service_name)
       Win32::Service.should_receive(:start).with(@new_resource.service_name)
       @provider.restart_service
@@ -154,17 +154,17 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     end
 
     it "should just start the service if it is stopped" do
-      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
-        mock("StatusStruct", :current_state => "stopped"),
-        mock("StatusStruct", :current_state => "stopped"),
-        mock("StatusStruct", :current_state => "running"))
+      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+        double("StatusStruct", :current_state => "stopped"),
+        double("StatusStruct", :current_state => "stopped"),
+        double("StatusStruct", :current_state => "running"))
       Win32::Service.should_receive(:start).with(@new_resource.service_name)
       @provider.restart_service
       @new_resource.updated_by_last_action?.should be_true
     end
 
     it "should do nothing if the service does not exist" do
-      Win32::Service.stub!(:exists?).with(@new_resource.service_name).and_return(false)
+      Win32::Service.stub(:exists?).with(@new_resource.service_name).and_return(false)
       Win32::Service.should_not_receive(:stop).with(@new_resource.service_name)
       Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
       @provider.restart_service
@@ -176,8 +176,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
   describe Chef::Provider::Service::Windows, "enable_service" do
 
     before(:each) do
-      Win32::Service.stub!(:config_info).with(@new_resource.service_name).and_return(
-        mock("ConfigStruct", :start_type => "disabled"))
+      Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+        double("ConfigStruct", :start_type => "disabled"))
     end
 
     it "should enable service" do
@@ -187,15 +187,15 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     end
 
     it "should do nothing if the service does not exist" do
-      Win32::Service.stub!(:exists?).with(@new_resource.service_name).and_return(false)
+      Win32::Service.stub(:exists?).with(@new_resource.service_name).and_return(false)
       Win32::Service.should_not_receive(:configure)
       @provider.enable_service
       @new_resource.updated_by_last_action?.should be_false
     end
 
     it "should do nothing if the service is enabled" do
-      Win32::Service.stub!(:config_info).with(@new_resource.service_name).and_return(
-        mock("ConfigStruct", :start_type => "auto start"))
+      Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+        double("ConfigStruct", :start_type => "auto start"))
       Win32::Service.should_not_receive(:configure)
       @provider.enable_service
       @new_resource.updated_by_last_action?.should be_false
@@ -205,8 +205,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
   describe Chef::Provider::Service::Windows, "disable_service" do
 
     before(:each) do
-      Win32::Service.stub!(:config_info).with(@new_resource.service_name).and_return(
-        mock("ConfigStruct", :start_type => "auto start"))
+      Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+        double("ConfigStruct", :start_type => "auto start"))
     end
 
     it "should disable service" do
@@ -216,15 +216,15 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     end
 
     it "should do nothing if the service does not exist" do
-      Win32::Service.stub!(:exists?).with(@new_resource.service_name).and_return(false)
+      Win32::Service.stub(:exists?).with(@new_resource.service_name).and_return(false)
       Win32::Service.should_not_receive(:configure)
       @provider.disable_service
       @new_resource.updated_by_last_action?.should be_false
     end
 
     it "should do nothing if the service is disabled" do
-      Win32::Service.stub!(:config_info).with(@new_resource.service_name).and_return(
-        mock("ConfigStruct", :start_type => "disabled"))
+      Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+        double("ConfigStruct", :start_type => "disabled"))
       @provider.load_current_resource
       Win32::Service.should_not_receive(:configure)
       @provider.disable_service