chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

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

@@ -41,22 +41,22 @@ describe Chef::Provider::Service::Upstart do
       @node.automatic_attrs[:platform_version] = '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 == ""
+      expect(@provider.instance_variable_get(:@upstart_job_dir)).to eq("/etc/event.d")
+      expect(@provider.instance_variable_get(:@upstart_conf_suffix)).to eq("")
     end
 
     it "should return /etc/init as the upstart job directory when running on Ubuntu 9.10" do
       @node.automatic_attrs[:platform_version] = '9.10'
       @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
-      @provider.instance_variable_get(:@upstart_job_dir).should == "/etc/init"
-      @provider.instance_variable_get(:@upstart_conf_suffix).should == ".conf"
+      expect(@provider.instance_variable_get(:@upstart_job_dir)).to eq("/etc/init")
+      expect(@provider.instance_variable_get(:@upstart_conf_suffix)).to eq(".conf")
     end
 
     it "should return /etc/init as the upstart job directory by default" do
       @node.automatic_attrs[:platform_version] = '9000'
       @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
-      @provider.instance_variable_get(:@upstart_job_dir).should == "/etc/init"
-      @provider.instance_variable_get(:@upstart_conf_suffix).should == ".conf"
+      expect(@provider.instance_variable_get(:@upstart_job_dir)).to eq("/etc/init")
+      expect(@provider.instance_variable_get(:@upstart_conf_suffix)).to eq(".conf")
     end
   end
 
@@ -65,26 +65,26 @@ 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)
+      allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
 
       @status = double("Status", :exitstatus => 0)
-      @provider.stub(:popen4).and_return(@status)
+      allow(@provider).to receive(:popen4).and_return(@status)
       @stdin = StringIO.new
       @stdout = StringIO.new
       @stderr = StringIO.new
       @pid = double("PID")
 
-      ::File.stub(:exists?).and_return(true)
-      ::File.stub(:open).and_return(true)
+      allow(::File).to receive(:exists?).and_return(true)
+      allow(::File).to receive(:open).and_return(true)
     end
 
     it "should create a current resource with the name of the new resource" do
-      Chef::Resource::Service.should_receive(:new).and_return(@current_resource)
+      expect(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
       @provider.load_current_resource
     end
 
     it "should set the current resources service name to the new resources service name" do
-      @current_resource.should_receive(:service_name).with(@new_resource.service_name)
+      expect(@current_resource).to receive(:service_name).with(@new_resource.service_name)
       @provider.load_current_resource
     end
 
@@ -92,11 +92,11 @@ describe Chef::Provider::Service::Upstart do
       @new_resource.parameters({ "OSD_ID" => "2" })
       @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
       @provider.current_resource = @current_resource
-      @new_resource.service_name.should == @current_resource.service_name
+      expect(@new_resource.service_name).to eq(@current_resource.service_name)
     end
 
     it "should run '/sbin/status rsyslog'" do
-      @provider.should_receive(:popen4).with("/sbin/status rsyslog").and_return(@status)
+      expect(@provider).to receive(:popen4).with("/sbin/status rsyslog").and_return(@status)
       @provider.load_current_resource
     end
 
@@ -106,99 +106,99 @@ 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)
+        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
-        @current_resource.running.should be_true
+        expect(@current_resource.running).to 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)
+        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
-        @current_resource.running.should be_false
+        expect(@current_resource.running).to be_false
       end
     end
 
     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)
+        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
-        @current_resource.running.should be_true
+        expect(@current_resource.running).to 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)
+        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
-        @current_resource.running.should be_false
+        expect(@current_resource.running).to 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)
-      @current_resource.should_receive(:running).with(false)
+      allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+      expect(@current_resource).to receive(:running).with(false)
       @provider.load_current_resource
     end
 
     it "should set enabled to true when it finds 'starts on'" do
       @lines = double("start on filesystem", :gets => "start on filesystem")
-      ::File.stub(:open).and_yield(@lines)
-      @current_resource.should_receive(:running).with(false)
+      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")
-      ::File.stub(:open).and_yield(@lines)
-      @current_resource.should_receive(:running).with(false)
+      allow(::File).to receive(:open).and_yield(@lines)
+      expect(@current_resource).to 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)
-      @current_resource.should_receive(:running).with(false)
+      allow(::File).to receive(:exists?).and_return(false)
+      expect(@current_resource).to receive(:running).with(false)
       @provider.load_current_resource
     end
 
     it "should track state when the upstart configuration file fails to load" do
-      File.should_receive(:exists?).and_return false
+      expect(File).to receive(:exists?).and_return false
       @provider.load_current_resource
-      @provider.instance_variable_get("@config_file_found").should == false
+      expect(@provider.instance_variable_get("@config_file_found")).to eq(false)
     end
 
     describe "when a status command has been specified" do
       before do
-        @new_resource.stub(:status_command).and_return("/bin/chefhasmonkeypants status")
+        allow(@new_resource).to receive(:status_command).and_return("/bin/chefhasmonkeypants status")
       end
 
       it "should run the services status command if one has been specified" do
-        @provider.stub(:shell_out!).with("/bin/chefhasmonkeypants status").and_return(0)
-        @current_resource.should_receive(:running).with(true)
+        allow(@provider).to receive(:shell_out!).with("/bin/chefhasmonkeypants status").and_return(0)
+        expect(@current_resource).to receive(:running).with(true)
         @provider.load_current_resource
       end
 
       it "should track state when the user-provided status command fails" do
-        @provider.stub(:shell_out!).and_raise(Errno::ENOENT)
+        allow(@provider).to receive(:shell_out!).and_raise(Errno::ENOENT)
         @provider.load_current_resource
-        @provider.instance_variable_get("@command_success").should == false
+        expect(@provider.instance_variable_get("@command_success")).to eq(false)
       end
 
       it "should set running to false if it catches a Chef::Exceptions::Exec when using a status command" do
-        @provider.stub(:shell_out!).and_raise(Errno::ENOENT)
-        @current_resource.should_receive(:running).with(false)
+        allow(@provider).to receive(:shell_out!).and_raise(Errno::ENOENT)
+        expect(@current_resource).to receive(:running).with(false)
         @provider.load_current_resource
       end
     end
 
     it "should track state when we fail to obtain service status via upstart_state" do
-      @provider.should_receive(:upstart_state).and_raise Chef::Exceptions::Exec
+      expect(@provider).to receive(:upstart_state).and_raise Chef::Exceptions::Exec
       @provider.load_current_resource
-      @provider.instance_variable_get("@command_success").should == false
+      expect(@provider.instance_variable_get("@command_success")).to eq(false)
     end
 
     it "should return the current resource" do
-      @provider.load_current_resource.should eql(@current_resource)
+      expect(@provider.load_current_resource).to eql(@current_resource)
     end
 
   end
@@ -206,26 +206,26 @@ 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)
+      allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
       @provider.current_resource = @current_resource
-      Chef::Util::FileEdit.stub(:new)
+      allow(Chef::Util::FileEdit).to receive(: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)
-      @file.should_receive(:search_file_replace)
-      @file.should_receive(:write_file)
+      allow(Chef::Util::FileEdit).to receive(:new).and_return(@file)
+      allow(@current_resource).to receive(:enabled).and_return(false)
+      expect(@file).to receive(:search_file_replace)
+      expect(@file).to receive(:write_file)
       @provider.enable_service()
     end
 
     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)
-      @file.should_receive(:search_file_replace)
-      @file.should_receive(:write_file)
+      allow(Chef::Util::FileEdit).to receive(:new).and_return(@file)
+      allow(@current_resource).to receive(:enabled).and_return(true)
+      expect(@file).to receive(:search_file_replace)
+      expect(@file).to receive(:write_file)
       @provider.disable_service()
     end
 
@@ -235,24 +235,24 @@ 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)
+      allow(Chef::Resource::Service).to receive(: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")
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog startyousillysally")
+      allow(@new_resource).to receive(:start_command).and_return("/sbin/rsyslog startyousillysally")
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog startyousillysally")
       @provider.start_service()
     end
 
     it "should call '/sbin/start service_name' if no start command is specified" do
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(0)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(0)
       @provider.start_service()
     end
 
     it "should not call '/sbin/start service_name' if it is already running" do
-      @current_resource.stub(:running).and_return(true)
-      @provider.should_not_receive(:shell_out_with_systems_locale!)
+      allow(@current_resource).to receive(:running).and_return(true)
+      expect(@provider).not_to receive(:shell_out_with_systems_locale!)
       @provider.start_service()
     end
 
@@ -261,58 +261,58 @@ describe Chef::Provider::Service::Upstart do
       @new_resource.parameters({ "OSD_ID" => "2" })
       @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
       @provider.current_resource = @current_resource
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/start rsyslog OSD_ID=2").and_return(0)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start rsyslog OSD_ID=2").and_return(0)
       @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")
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog restartyousillysally")
+      allow(@current_resource).to receive(:running).and_return(true)
+      allow(@new_resource).to receive(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
+      expect(@provider).to receive(:shell_out_with_systems_locale!).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)
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/restart #{@new_resource.service_name}").and_return(0)
+      allow(@current_resource).to receive(:running).and_return(true)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/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)
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(0)
+      allow(@current_resource).to receive(:running).and_return(false)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/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")
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog reloadyousillysally")
+      allow(@current_resource).to receive(:running).and_return(true)
+      allow(@new_resource).to receive(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
+      expect(@provider).to receive(:shell_out_with_systems_locale!).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)
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/reload #{@new_resource.service_name}").and_return(0)
+      allow(@current_resource).to receive(:running).and_return(true)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/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")
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog stopyousillysally")
+      allow(@current_resource).to receive(:running).and_return(true)
+      allow(@new_resource).to receive(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
+      expect(@provider).to receive(:shell_out_with_systems_locale!).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)
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/stop #{@new_resource.service_name}").and_return(0)
+      allow(@current_resource).to receive(:running).and_return(true)
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/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)
-      @provider.should_not_receive(:shell_out_with_systems_locale!).with("/sbin/stop #{@new_resource.service_name}")
+      allow(@current_resource).to receive(:running).and_return(false)
+      expect(@provider).not_to receive(:shell_out_with_systems_locale!).with("/sbin/stop #{@new_resource.service_name}")
       @provider.stop_service()
     end
   end

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

@@ -33,102 +33,102 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     Win32::Service::AUTO_START = 0x00000002
     Win32::Service::DEMAND_START = 0x00000003
     Win32::Service::DISABLED = 0x00000004
-    Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+    allow(Win32::Service).to receive(: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(
+    allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
       double("ConfigStruct", :start_type => "auto start"))
-    Win32::Service.stub(:exists?).and_return(true)
+    allow(Win32::Service).to receive(:exists?).and_return(true)
   end
 
   it "should set the current resources service name to the new resources service name" do
     @provider.load_current_resource
-    @provider.current_resource.service_name.should == 'chef'
+    expect(@provider.current_resource.service_name).to eq('chef')
   end
 
   it "should return the current resource" do
-    @provider.load_current_resource.should equal(@provider.current_resource)
+    expect(@provider.load_current_resource).to equal(@provider.current_resource)
   end
 
   it "should set the current resources status" do
     @provider.load_current_resource
-    @provider.current_resource.running.should be_true
+    expect(@provider.current_resource.running).to be_true
   end
 
   it "should set the current resources start type" do
     @provider.load_current_resource
-    @provider.current_resource.enabled.should be_true
+    expect(@provider.current_resource.enabled).to be_true
   end
 
   it "does not set the current resources start type if it is neither AUTO START or DISABLED" do
-    Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+    allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
       double("ConfigStruct", :start_type => "manual"))
     @provider.load_current_resource
-    @provider.current_resource.enabled.should be_nil
+    expect(@provider.current_resource.enabled).to be_nil
   end
 
   describe Chef::Provider::Service::Windows, "start_service" do
     before(:each) do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(: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
       @new_resource.start_command "sc start chef"
-      @provider.should_receive(:shell_out!).with("#{@new_resource.start_command}").and_return("Starting custom service")
+      expect(@provider).to receive(:shell_out!).with("#{@new_resource.start_command}").and_return("Starting custom service")
       @provider.start_service
-      @new_resource.updated_by_last_action?.should be_true
+      expect(@new_resource.updated_by_last_action?).to be_true
     end
 
     it "should use the built-in command if no start command is specified" do
-      Win32::Service.should_receive(:start).with(@new_resource.service_name)
+      expect(Win32::Service).to receive(:start).with(@new_resource.service_name)
       @provider.start_service
-      @new_resource.updated_by_last_action?.should be_true
+      expect(@new_resource.updated_by_last_action?).to 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.should_not_receive(:start).with(@new_resource.service_name)
+      allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
+      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       @provider.start_service
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
     it "should do nothing if the service is running" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(: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)
+      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       @provider.start_service
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
     it "should raise an error if the service is paused" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "paused"))
       @provider.load_current_resource
-      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       expect { @provider.start_service }.to raise_error( Chef::Exceptions::Service )
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
     it "should wait and continue if the service is in start_pending" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      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"))
       @provider.load_current_resource
-      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       @provider.start_service
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
     it "should fail if the service is in stop_pending" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "stop pending"))
       @provider.load_current_resource
-      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       expect { @provider.start_service }.to raise_error( Chef::Exceptions::Service )
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
   end
@@ -137,78 +137,78 @@ 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(
+      allow(Win32::Service).to receive(: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
       @new_resource.stop_command "sc stop chef"
-      @provider.should_receive(:shell_out!).with("#{@new_resource.stop_command}").and_return("Stopping custom service")
+      expect(@provider).to receive(:shell_out!).with("#{@new_resource.stop_command}").and_return("Stopping custom service")
       @provider.stop_service
-      @new_resource.updated_by_last_action?.should be_true
+      expect(@new_resource.updated_by_last_action?).to be_true
     end
 
     it "should use the built-in command if no stop command is specified" do
-      Win32::Service.should_receive(:stop).with(@new_resource.service_name)
+      expect(Win32::Service).to receive(:stop).with(@new_resource.service_name)
       @provider.stop_service
-      @new_resource.updated_by_last_action?.should be_true
+      expect(@new_resource.updated_by_last_action?).to 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.should_not_receive(:stop).with(@new_resource.service_name)
+      allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
+      expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
       @provider.stop_service
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
     it "should do nothing if the service is stopped" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(: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)
+      expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
       @provider.stop_service
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
     it "should raise an error if the service is paused" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "paused"))
       @provider.load_current_resource
-      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       expect { @provider.stop_service }.to raise_error( Chef::Exceptions::Service )
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
     it "should wait and continue if the service is in stop_pending" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      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"))
       @provider.load_current_resource
-      Win32::Service.should_not_receive(:stop).with(@new_resource.service_name)
+      expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
       @provider.stop_service
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
     it "should fail if the service is in start_pending" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "start pending"))
       @provider.load_current_resource
-      Win32::Service.should_not_receive(:stop).with(@new_resource.service_name)
+      expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
       expect { @provider.stop_service }.to raise_error( Chef::Exceptions::Service )
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
     it "should pass custom timeout to the stop command if provided" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:status).with(@new_resource.service_name).and_return(
         double("StatusStruct", :current_state => "running"))
       @new_resource.timeout 1
-      Win32::Service.should_receive(:stop).with(@new_resource.service_name)
+      expect(Win32::Service).to receive(:stop).with(@new_resource.service_name)
       Timeout.timeout(2) do
         expect { @provider.stop_service }.to raise_error(Timeout::Error)
       end
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
   end
@@ -217,112 +217,112 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
 
     it "should call the restart command if one is specified" do
       @new_resource.restart_command "sc restart"
-      @provider.should_receive(:shell_out!).with("#{@new_resource.restart_command}")
+      expect(@provider).to receive(:shell_out!).with("#{@new_resource.restart_command}")
       @provider.restart_service
-      @new_resource.updated_by_last_action?.should be_true
+      expect(@new_resource.updated_by_last_action?).to be_true
     end
 
     it "should stop then start the service if it is running" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      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"))
-      Win32::Service.should_receive(:stop).with(@new_resource.service_name)
-      Win32::Service.should_receive(:start).with(@new_resource.service_name)
+      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
-      @new_resource.updated_by_last_action?.should be_true
+      expect(@new_resource.updated_by_last_action?).to be_true
     end
 
     it "should just start the service if it is stopped" do
-      Win32::Service.stub(:status).with(@new_resource.service_name).and_return(
+      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"))
-      Win32::Service.should_receive(:start).with(@new_resource.service_name)
+      expect(Win32::Service).to receive(:start).with(@new_resource.service_name)
       @provider.restart_service
-      @new_resource.updated_by_last_action?.should be_true
+      expect(@new_resource.updated_by_last_action?).to 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.should_not_receive(:stop).with(@new_resource.service_name)
-      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
+      expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
+      expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       @provider.restart_service
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
 
   end
 
   describe Chef::Provider::Service::Windows, "enable_service" do
     before(:each) do
-      Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "disabled"))
     end
 
     it "should enable service" do
-      Win32::Service.should_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
-      @new_resource.updated_by_last_action?.should be_true
+      expect(@new_resource.updated_by_last_action?).to 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.should_not_receive(:configure)
+      allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
+      expect(Win32::Service).not_to receive(:configure)
       @provider.enable_service
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
   end
 
   describe Chef::Provider::Service::Windows, "action_enable" do
     it "does nothing if the service is enabled" do
-      Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "auto start"))
-      @provider.should_not_receive(:enable_service)
+      expect(@provider).not_to receive(:enable_service)
       @provider.action_enable
     end
 
     it "enables the service if it is not set to automatic start" do
-      Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "disabled"))
-      @provider.should_receive(:enable_service)
+      expect(@provider).to receive(:enable_service)
       @provider.action_enable
     end
   end
 
   describe Chef::Provider::Service::Windows, "action_disable" do
     it "does nothing if the service is disabled" do
-      Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "disabled"))
-      @provider.should_not_receive(:disable_service)
+      expect(@provider).not_to receive(:disable_service)
       @provider.action_disable
     end
 
     it "disables the service if it is not set to disabled" do
-      Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "auto start"))
-      @provider.should_receive(:disable_service)
+      expect(@provider).to receive(:disable_service)
       @provider.action_disable
     end
   end
 
   describe Chef::Provider::Service::Windows, "disable_service" do
     before(:each) do
-      Win32::Service.stub(:config_info).with(@new_resource.service_name).and_return(
+      allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
         double("ConfigStruct", :start_type => "auto start"))
     end
 
     it "should disable service" do
-      Win32::Service.should_receive(:configure)
+      expect(Win32::Service).to receive(:configure)
       @provider.disable_service
-      @new_resource.updated_by_last_action?.should be_true
+      expect(@new_resource.updated_by_last_action?).to 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.should_not_receive(:configure)
+      allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
+      expect(Win32::Service).not_to receive(:configure)
       @provider.disable_service
-      @new_resource.updated_by_last_action?.should be_false
+      expect(@new_resource.updated_by_last_action?).to be_false
     end
   end
 
@@ -330,15 +330,15 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     { :automatic => "auto start", :manual => "demand start", :disabled => "disabled" }.each do |type,win32|
       it "sets the startup type to #{type} if it is something else" do
         @new_resource.startup_type(type)
-        @provider.stub(:current_start_type).and_return("fire")
-        @provider.should_receive(:set_startup_type).with(type)
+        allow(@provider).to receive(:current_start_type).and_return("fire")
+        expect(@provider).to receive(:set_startup_type).with(type)
         @provider.action_configure_startup
       end
 
       it "leaves the startup type as #{type} if it is already set" do
         @new_resource.startup_type(type)
-        @provider.stub(:current_start_type).and_return(win32)
-        @provider.should_not_receive(:set_startup_type).with(type)
+        allow(@provider).to receive(:current_start_type).and_return(win32)
+        expect(@provider).not_to receive(:set_startup_type).with(type)
         @provider.action_configure_startup
       end
     end
@@ -346,17 +346,17 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
 
   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
-      Win32::Service.should_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
-      Win32::Service.should_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
-      Win32::Service.should_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