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

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

@@ -22,21 +22,21 @@ describe Chef::Provider::Service::Macosx do
   describe ".gather_plist_dirs" do
     context "when HOME directory is set" do
       before do
-        ENV.stub(:[]).with('HOME').and_return("/User/someuser")
+        allow(ENV).to receive(:[]).with('HOME').and_return("/User/someuser")
       end
 
       it "includes users's LaunchAgents folder" do
-        described_class.gather_plist_dirs.should include("#{ENV['HOME']}/Library/LaunchAgents")
+        expect(described_class.gather_plist_dirs).to include("#{ENV['HOME']}/Library/LaunchAgents")
       end
     end
 
     context "when HOME directory is not set" do
       before do
-        ENV.stub(:[]).with('HOME').and_return(nil)
+        allow(ENV).to receive(:[]).with('HOME').and_return(nil)
       end
 
       it "doesn't include user's LaunchAgents folder" do
-        described_class.gather_plist_dirs.should_not include("~/Library/LaunchAgents")
+        expect(described_class.gather_plist_dirs).not_to include("~/Library/LaunchAgents")
       end
     end
   end
@@ -60,20 +60,20 @@ XML
 
     ["redis-server", "io.redis.redis-server"].each do |service_name|
       before do
-        Dir.stub(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist"], [])
-        provider.stub(:shell_out!).
+        allow(Dir).to receive(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist"], [])
+        allow(provider).to receive(:shell_out!).
                  with("launchctl list", {:group => 1001, :user => 101}).
                  and_return(double("Status", :stdout => launchctl_stdout))
-        provider.stub(:shell_out).
+        allow(provider).to receive(:shell_out).
                  with(/launchctl list /,
                       {:group => nil, :user => nil}).
                  and_return(double("Status",
                                  :stdout => launchctl_stdout, :exitstatus => 0))
-        provider.stub(:shell_out!).
+        allow(provider).to receive(:shell_out!).
                  with(/plutil -convert xml1 -o/).
                  and_return(double("Status", :stdout => plutil_stdout))
 
-        File.stub(:stat).and_return(double("stat", :gid => 1001, :uid => 101))
+        allow(File).to receive(:stat).and_return(double("stat", :gid => 1001, :uid => 101))
       end
 
       context "#{service_name}" do
@@ -95,26 +95,26 @@ XML
             end
 
             before do
-              Dir.stub(:glob).and_return([])
-              provider.stub(:shell_out!).
+              allow(Dir).to receive(:glob).and_return([])
+              allow(provider).to receive(:shell_out!).
                        with(/plutil -convert xml1 -o/).
                        and_raise(Mixlib::ShellOut::ShellCommandFailed)
             end
 
             it "works for action :nothing" do
-              lambda { run_resource_setup_for_action(:nothing) }.should_not raise_error
+              expect { run_resource_setup_for_action(:nothing) }.not_to raise_error
             end
 
             it "works for action :start" do
-              lambda { run_resource_setup_for_action(:start) }.should_not raise_error
+              expect { run_resource_setup_for_action(:start) }.not_to raise_error
             end
 
             it "errors if action is :enable" do
-              lambda { run_resource_setup_for_action(:enable) }.should raise_error(Chef::Exceptions::Service)
+              expect { run_resource_setup_for_action(:enable) }.to raise_error(Chef::Exceptions::Service)
             end
 
             it "errors if action is :disable" do
-              lambda { run_resource_setup_for_action(:disable) }.should raise_error(Chef::Exceptions::Service)
+              expect { run_resource_setup_for_action(:disable) }.to raise_error(Chef::Exceptions::Service)
             end
           end
 
@@ -130,11 +130,11 @@ XML
             end
 
             it "sets resource running state to true" do
-              provider.current_resource.running.should be_true
+              expect(provider.current_resource.running).to be_true
             end
 
             it "sets resouce enabled state to true" do
-              provider.current_resource.enabled.should be_true
+              expect(provider.current_resource.enabled).to be_true
             end
           end
 
@@ -146,10 +146,10 @@ XML
 SVC_LIST
 
             before do
-              Dir.stub(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist"], [])
+              allow(Dir).to receive(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist"], [])
             end
             it "should throw an exception when reload action is attempted" do
-              lambda {provider.run_action(:reload)}.should raise_error(Chef::Exceptions::UnsupportedAction)
+              expect {provider.run_action(:reload)}.to raise_error(Chef::Exceptions::UnsupportedAction)
             end
           end
           context "when launchctl returns empty service pid" do
@@ -164,11 +164,11 @@ SVC_LIST
             end
 
             it "sets resource running state to false" do
-              provider.current_resource.running.should be_false
+              expect(provider.current_resource.running).to be_false
             end
 
             it "sets resouce enabled state to true" do
-              provider.current_resource.enabled.should be_true
+              expect(provider.current_resource.enabled).to be_true
             end
           end
 
@@ -180,65 +180,65 @@ SVC_LIST
 
             it "sets service running state to false" do
               provider.load_current_resource
-              provider.current_resource.running.should be_false
+              expect(provider.current_resource.running).to be_false
             end
 
             context "and plist for service is not available" do
               before do
-                Dir.stub(:glob).and_return([])
+                allow(Dir).to receive(:glob).and_return([])
                 provider.load_current_resource
               end
 
               it "sets resouce enabled state to false" do
-                provider.current_resource.enabled.should be_false
+                expect(provider.current_resource.enabled).to be_false
               end
             end
 
             context "and plist for service is available" do
               before do
-                Dir.stub(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist"], [])
+                allow(Dir).to receive(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist"], [])
                 provider.load_current_resource
               end
 
               it "sets resouce enabled state to true" do
-                provider.current_resource.enabled.should be_true
+                expect(provider.current_resource.enabled).to be_true
               end
             end
 
             describe "and several plists match service name" do
               it "throws exception" do
-                Dir.stub(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist",
+                allow(Dir).to receive(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist",
                                              "/Users/wtf/something.plist"])
                 provider.load_current_resource
                 provider.define_resource_requirements
-                lambda { provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+                expect { provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
               end
             end
           end
         end
         describe "#start_service" do
           before do
-            Chef::Resource::Service.stub(:new).and_return(current_resource)
+            allow(Chef::Resource::Service).to receive(:new).and_return(current_resource)
             provider.load_current_resource
-            current_resource.stub(:running).and_return(false)
+            allow(current_resource).to receive(:running).and_return(false)
           end
 
           it "calls the start command if one is specified and service is not running" do
-            new_resource.stub(:start_command).and_return("cowsay dirty")
+            allow(new_resource).to receive(:start_command).and_return("cowsay dirty")
 
-            provider.should_receive(:shell_out_with_systems_locale!).with("cowsay dirty")
+            expect(provider).to receive(:shell_out_with_systems_locale!).with("cowsay dirty")
             provider.start_service
           end
 
           it "shows warning message if service is already running" do
-            current_resource.stub(:running).and_return(true)
-            Chef::Log.should_receive(:debug).with("service[#{service_name}] already running, not starting")
+            allow(current_resource).to receive(:running).and_return(true)
+            expect(Chef::Log).to receive(:debug).with("service[#{service_name}] already running, not starting")
 
             provider.start_service
           end
 
           it "starts service via launchctl if service found" do
-            provider.should_receive(:shell_out_with_systems_locale!).
+            expect(provider).to receive(:shell_out_with_systems_locale!).
                      with("launchctl load -w '/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist'",
                            :group => 1001, :user => 101).
                      and_return(0)
@@ -249,28 +249,28 @@ SVC_LIST
 
         describe "#stop_service" do
           before do
-            Chef::Resource::Service.stub(:new).and_return(current_resource)
+            allow(Chef::Resource::Service).to receive(:new).and_return(current_resource)
 
             provider.load_current_resource
-            current_resource.stub(:running).and_return(true)
+            allow(current_resource).to receive(:running).and_return(true)
           end
 
           it "calls the stop command if one is specified and service is running" do
-            new_resource.stub(:stop_command).and_return("kill -9 123")
+            allow(new_resource).to receive(:stop_command).and_return("kill -9 123")
 
-            provider.should_receive(:shell_out_with_systems_locale!).with("kill -9 123")
+            expect(provider).to receive(:shell_out_with_systems_locale!).with("kill -9 123")
             provider.stop_service
           end
 
           it "shows warning message if service is not running" do
-            current_resource.stub(:running).and_return(false)
-            Chef::Log.should_receive(:debug).with("service[#{service_name}] not running, not stopping")
+            allow(current_resource).to receive(:running).and_return(false)
+            expect(Chef::Log).to receive(:debug).with("service[#{service_name}] not running, not stopping")
 
             provider.stop_service
           end
 
           it "stops the service via launchctl if service found" do
-            provider.should_receive(:shell_out_with_systems_locale!).
+            expect(provider).to receive(:shell_out_with_systems_locale!).
                      with("launchctl unload '/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist'",
                           :group => 1001, :user => 101).
                      and_return(0)
@@ -281,23 +281,23 @@ SVC_LIST
 
         describe "#restart_service" do
           before do
-            Chef::Resource::Service.stub(:new).and_return(current_resource)
+            allow(Chef::Resource::Service).to receive(:new).and_return(current_resource)
 
             provider.load_current_resource
-            current_resource.stub(:running).and_return(true)
-            provider.stub(:sleep)
+            allow(current_resource).to receive(:running).and_return(true)
+            allow(provider).to receive(:sleep)
           end
 
           it "issues a command if given" do
-            new_resource.stub(:restart_command).and_return("reload that thing")
+            allow(new_resource).to receive(:restart_command).and_return("reload that thing")
 
-            provider.should_receive(:shell_out_with_systems_locale!).with("reload that thing")
+            expect(provider).to receive(:shell_out_with_systems_locale!).with("reload that thing")
             provider.restart_service
           end
 
           it "stops and then starts service" do
-            provider.should_receive(:stop_service)
-            provider.should_receive(:start_service);
+            expect(provider).to receive(:stop_service)
+            expect(provider).to receive(:start_service);
 
             provider.restart_service
           end

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

@@ -21,22 +21,22 @@ require 'ostruct'
 
 shared_examples_for "define_resource_requirements_common" do
   it "should raise an error if /sbin/chkconfig does not exist" do
-    File.stub(:exists?).with("/sbin/chkconfig").and_return(false)
-    @provider.stub(:shell_out).with("/sbin/service chef status").and_raise(Errno::ENOENT)
-    @provider.stub(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_raise(Errno::ENOENT)
+    allow(File).to receive(:exists?).with("/sbin/chkconfig").and_return(false)
+    allow(@provider).to receive(:shell_out).with("/sbin/service chef status").and_raise(Errno::ENOENT)
+    allow(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_raise(Errno::ENOENT)
     @provider.load_current_resource
     @provider.define_resource_requirements
-    lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
   end
 
   it "should not raise an error if the service exists but is not added to any runlevels" do
     status = double("Status", :exitstatus => 0, :stdout => "" , :stderr => "")
-    @provider.should_receive(:shell_out).with("/sbin/service chef status").and_return(status)
+    expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
     chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "", :stderr => "service chef supports chkconfig, but is not referenced in any runlevel (run 'chkconfig --add chef')")
-    @provider.should_receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+    expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
     @provider.load_current_resource
     @provider.define_resource_requirements
-    lambda { @provider.process_resource_requirements }.should_not raise_error
+    expect { @provider.process_resource_requirements }.not_to raise_error
   end
 end
 
@@ -54,8 +54,8 @@ describe "Chef::Provider::Service::Redhat" do
 
     @provider = Chef::Provider::Service::Redhat.new(@new_resource, @run_context)
     @provider.action = :start
-    Chef::Resource::Service.stub(:new).and_return(@current_resource)
-    File.stub(:exists?).with("/sbin/chkconfig").and_return(true)
+    allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
+    allow(File).to receive(:exists?).with("/sbin/chkconfig").and_return(true)
   end
 
   describe "while not in why run mode" do
@@ -66,22 +66,22 @@ describe "Chef::Provider::Service::Redhat" do
     describe "load current resource" do
       it "sets the current enabled status to true if the service is enabled for any run level" do
         status = double("Status", :exitstatus => 0, :stdout => "" , :stderr => "")
-        @provider.should_receive(:shell_out).with("/sbin/service chef status").and_return(status)
+        expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
         chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", :stderr => "")
-        @provider.should_receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
-        @provider.instance_variable_get("@service_missing").should be_false
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        expect(@provider.instance_variable_get("@service_missing")).to be_false
         @provider.load_current_resource
-        @current_resource.enabled.should be_true
+        expect(@current_resource.enabled).to be_true
       end
 
       it "sets the current enabled status to false if the regex does not match" do
         status = double("Status", :exitstatus => 0, :stdout => "" , :stderr => "")
-        @provider.should_receive(:shell_out).with("/sbin/service chef status").and_return(status)
+        expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
         chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:off   6:off", :stderr => "")
-        @provider.should_receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
-        @provider.instance_variable_get("@service_missing").should be_false
-        @provider.load_current_resource.should eql(@current_resource)
-        @current_resource.enabled.should be_false
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        expect(@provider.instance_variable_get("@service_missing")).to be_false
+        expect(@provider.load_current_resource).to eql(@current_resource)
+        expect(@current_resource.enabled).to be_false
       end
     end
 
@@ -91,9 +91,9 @@ describe "Chef::Provider::Service::Redhat" do
       context "when the service does not exist" do
         before do
           status = double("Status", :exitstatus => 1, :stdout => "", :stderr => "chef: unrecognized service")
-          @provider.should_receive(:shell_out).with("/sbin/service chef status").and_return(status)
+          expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
           chkconfig = double("Chkconfig", :existatus=> 1, :stdout => "", :stderr => "error reading information on service chef: No such file or directory")
-          @provider.should_receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+          expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
           @provider.load_current_resource
           @provider.define_resource_requirements
         end
@@ -101,14 +101,14 @@ describe "Chef::Provider::Service::Redhat" do
         [ "start", "reload", "restart", "enable" ].each do |action|
           it "should raise an error when the action is #{action}" do
             @provider.action = action
-            lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+            expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
           end
         end
 
         [ "stop", "disable" ].each do |action|
           it "should not raise an error when the action is #{action}" do
             @provider.action = action
-            lambda { @provider.process_resource_requirements }.should_not raise_error
+            expect { @provider.process_resource_requirements }.not_to raise_error
           end
         end
       end
@@ -129,26 +129,26 @@ describe "Chef::Provider::Service::Redhat" do
 
       it "should not raise an error if the service does not exist" do
         status = double("Status", :exitstatus => 1, :stdout => "", :stderr => "chef: unrecognized service")
-        @provider.should_receive(:shell_out).with("/sbin/service chef status").and_return(status)
+        expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
         chkconfig = double("Chkconfig", :existatus=> 1, :stdout => "", :stderr => "error reading information on service chef: No such file or directory")
-        @provider.should_receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
         @provider.load_current_resource
         @provider.define_resource_requirements
-        lambda { @provider.process_resource_requirements }.should_not raise_error
+        expect { @provider.process_resource_requirements }.not_to raise_error
       end
     end
   end
 
   describe "enable_service" do
     it "should call chkconfig to add 'service_name'" do
-      @provider.should_receive(:shell_out!).with("/sbin/chkconfig #{@new_resource.service_name} on")
+      expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig #{@new_resource.service_name} on")
       @provider.enable_service
     end
   end
 
   describe "disable_service" do
     it "should call chkconfig to del 'service_name'" do
-      @provider.should_receive(:shell_out!).with("/sbin/chkconfig #{@new_resource.service_name} off")
+      expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig #{@new_resource.service_name} off")
       @provider.disable_service
     end
   end

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

@@ -29,7 +29,7 @@ describe Chef::Provider::Service::Simple, "load_current_resource" do
     @current_resource = Chef::Resource::Service.new("chef")
 
     @provider = Chef::Provider::Service::Simple.new(@new_resource, @run_context)
-    Chef::Resource::Service.stub(:new).and_return(@current_resource)
+    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
@@ -37,40 +37,40 @@ 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)
-    @provider.stub(:shell_out!).and_return(@status)
+    allow(@provider).to receive(:shell_out!).and_return(@status)
   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
 
   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}
     @provider.define_resource_requirements
-    lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    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 => ""}
     @provider.define_resource_requirements
-    lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
   end
 
   describe "when we have a 'ps' attribute" do
     it "should shell_out! the node's ps command" do
-      @provider.should_receive(:shell_out!).with(@node[:command][:ps]).and_return(@status)
+      expect(@provider).to receive(:shell_out!).with(@node[:command][:ps]).and_return(@status)
       @provider.load_current_resource
     end
 
     it "should read stdout of the ps command" do
-      @provider.stub(:shell_out!).and_return(@status)
-      @stdout.should_receive(:each_line).and_return(true)
+      allow(@provider).to receive(:shell_out!).and_return(@status)
+      expect(@stdout).to receive(:each_line).and_return(true)
       @provider.load_current_resource
     end
 
@@ -80,75 +80,75 @@ 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)
-      @provider.stub(:shell_out!).and_return(@status)
+      allow(@provider).to receive(:shell_out!).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 regex doesn't match" do
-      @provider.stub(:shell_out!).and_return(@status)
+      allow(@provider).to receive(:shell_out!).and_return(@status)
       @provider.load_current_resource
-      @current_resource.running.should be_false
+      expect(@current_resource.running).to be_false
     end
 
     it "should raise an exception if ps fails" do
-      @provider.stub(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      allow(@provider).to receive(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
       @provider.action = :start
       @provider.load_current_resource
       @provider.define_resource_requirements
-      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
     end
   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
 
   describe "when starting the service" do
     it "should call the start command if one is specified" do
-      @new_resource.stub(:start_command).and_return("#{@new_resource.start_command}")
-      @provider.should_receive(:shell_out_with_systems_locale!).with("#{@new_resource.start_command}")
+      allow(@new_resource).to receive(:start_command).and_return("#{@new_resource.start_command}")
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("#{@new_resource.start_command}")
       @provider.start_service()
     end
 
     it "should raise an exception if no start command is specified" do
       @provider.define_resource_requirements
       @provider.action = :start
-      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
     end
   end
 
   describe "when stopping a service" do
     it "should call the stop command if one is specified" do
       @new_resource.stop_command("/etc/init.d/themadness stop")
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/etc/init.d/themadness stop")
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/etc/init.d/themadness stop")
       @provider.stop_service()
     end
 
     it "should raise an exception if no stop command is specified" do
       @provider.define_resource_requirements
       @provider.action = :stop
-      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
     end
   end
 
   describe Chef::Provider::Service::Simple, "restart_service" do
     it "should call the restart command if one has been specified" do
       @new_resource.restart_command("/etc/init.d/foo restart")
-      @provider.should_receive(:shell_out_with_systems_locale!).with("/etc/init.d/foo restart")
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/etc/init.d/foo restart")
       @provider.restart_service()
     end
 
     it "should raise an exception if the resource doesn't support restart, no restart command is provided, and no stop command is provided" do
       @provider.define_resource_requirements
       @provider.action = :restart
-      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
     end
 
     it "should just call stop, then start when the resource doesn't support restart and no restart_command is specified" do
-      @provider.should_receive(:stop_service)
-      @provider.should_receive(:sleep).with(1)
-      @provider.should_receive(:start_service)
+      expect(@provider).to receive(:stop_service)
+      expect(@provider).to receive(:sleep).with(1)
+      expect(@provider).to receive(:start_service)
       @provider.restart_service()
     end
   end
@@ -157,12 +157,12 @@ NOMOCKINGSTRINGSPLZ
     it "should raise an exception if reload is requested but no command is specified" do
       @provider.define_resource_requirements
       @provider.action = :reload
-      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::UnsupportedAction)
+      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::UnsupportedAction)
     end
 
     it "should should run the user specified reload command if one is specified" do
       @new_resource.reload_command("kill -9 1")
-      @provider.should_receive(:shell_out_with_systems_locale!).with("kill -9 1")
+      expect(@provider).to receive(:shell_out_with_systems_locale!).with("kill -9 1")
       @provider.reload_service()
     end
   end