puppet 5.5.12-x86-mingw32 → 5.5.13-x86-mingw32

data/spec/unit/provider/selboolean_spec.rb

@@ -1,36 +1,34 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:selboolean).provider(:getsetsebool)
 
 describe provider_class do
   before :each do
-    @resource = stub("resource", :name => "foo")
-    @resource.stubs(:[]).returns "foo"
+    @resource = double("resource", :name => "foo")
+    allow(@resource).to receive(:[]).and_return("foo")
     @provider = provider_class.new(@resource)
   end
 
   it "should return :on when getsebool returns on" do
-    @provider.expects(:getsebool).with("foo").returns "foo --> on\n"
+    expect(@provider).to receive(:getsebool).with("foo").and_return("foo --> on\n")
     expect(@provider.value).to eq(:on)
   end
 
   it "should return :off when getsebool returns on" do
-    @provider.expects(:getsebool).with("foo").returns "foo --> off\n"
+    expect(@provider).to receive(:getsebool).with("foo").and_return("foo --> off\n")
     expect(@provider.value).to eq(:off)
   end
 
   it "should call execpipe when updating boolean setting" do
-    @provider.expects(:command).with(:setsebool).returns "/usr/sbin/setsebool"
-    @provider.expects(:execpipe).with("/usr/sbin/setsebool  foo off")
+    expect(@provider).to receive(:command).with(:setsebool).and_return("/usr/sbin/setsebool")
+    expect(@provider).to receive(:execpipe).with("/usr/sbin/setsebool  foo off")
     @provider.value = :off
   end
 
   it "should call execpipe with -P when updating persistent boolean setting" do
-    @resource.stubs(:[]).with(:persistent).returns :true
-    @provider.expects(:command).with(:setsebool).returns "/usr/sbin/setsebool"
-    @provider.expects(:execpipe).with("/usr/sbin/setsebool -P foo off")
+    allow(@resource).to receive(:[]).with(:persistent).and_return(:true)
+    expect(@provider).to receive(:command).with(:setsebool).and_return("/usr/sbin/setsebool")
+    expect(@provider).to receive(:execpipe).with("/usr/sbin/setsebool -P foo off")
     @provider.value = :off
   end
-
 end

data/spec/unit/provider/selmodule_spec.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 # Note: This unit test depends on having a sample SELinux policy file
 # in the same directory as this test called selmodule-example.pp
 # with version 1.5.0.  The provided selmodule-example.pp is the first
@@ -12,73 +10,73 @@ provider_class = Puppet::Type.type(:selmodule).provider(:semodule)
 
 describe provider_class do
   before :each do
-    @resource = stub("resource", :name => "foo")
-    @resource.stubs(:[]).returns "foo"
+    @resource = double("resource", :name => "foo")
+    allow(@resource).to receive(:[]).and_return("foo")
     @provider = provider_class.new(@resource)
   end
 
   describe "exists? method" do
     it "should find a module if it is already loaded" do
-      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("bar\t1.2.3\nfoo\t4.4.4\nbang\t1.0.0\n")
+      expect(@provider).to receive(:command).with(:semodule).and_return("/usr/sbin/semodule")
+      expect(@provider).to receive(:execpipe).with("/usr/sbin/semodule --list").and_yield(StringIO.new("bar\t1.2.3\nfoo\t4.4.4\nbang\t1.0.0\n"))
       expect(@provider.exists?).to eq(:true)
     end
 
     it "should return nil if not loaded" do
-      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("bar\t1.2.3\nbang\t1.0.0\n")
+      expect(@provider).to receive(:command).with(:semodule).and_return("/usr/sbin/semodule")
+      expect(@provider).to receive(:execpipe).with("/usr/sbin/semodule --list").and_yield(StringIO.new("bar\t1.2.3\nbang\t1.0.0\n"))
       expect(@provider.exists?).to be_nil
     end
 
     it "should return nil if module with same suffix is loaded" do
-      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("bar\t1.2.3\nmyfoo\t1.0.0\n")
+      expect(@provider).to receive(:command).with(:semodule).and_return("/usr/sbin/semodule")
+      expect(@provider).to receive(:execpipe).with("/usr/sbin/semodule --list").and_yield(StringIO.new("bar\t1.2.3\nmyfoo\t1.0.0\n"))
       expect(@provider.exists?).to be_nil
     end
 
     it "should return nil if no modules are loaded" do
-      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("")
+      expect(@provider).to receive(:command).with(:semodule).and_return("/usr/sbin/semodule")
+      expect(@provider).to receive(:execpipe).with("/usr/sbin/semodule --list").and_yield(StringIO.new(""))
       expect(@provider.exists?).to be_nil
     end
   end
 
   describe "selmodversion_file" do
     it "should return 1.5.0 for the example policy file" do
-      @provider.expects(:selmod_name_to_filename).returns "#{File.dirname(__FILE__)}/selmodule-example.pp"
+      expect(@provider).to receive(:selmod_name_to_filename).and_return("#{File.dirname(__FILE__)}/selmodule-example.pp")
       expect(@provider.selmodversion_file).to eq("1.5.0")
     end
   end
 
   describe "syncversion" do
     it "should return :true if loaded and file modules are in sync" do
-      @provider.expects(:selmodversion_loaded).returns "1.5.0"
-      @provider.expects(:selmodversion_file).returns "1.5.0"
+      expect(@provider).to receive(:selmodversion_loaded).and_return("1.5.0")
+      expect(@provider).to receive(:selmodversion_file).and_return("1.5.0")
       expect(@provider.syncversion).to eq(:true)
     end
 
     it "should return :false if loaded and file modules are not in sync" do
-      @provider.expects(:selmodversion_loaded).returns "1.4.0"
-      @provider.expects(:selmodversion_file).returns "1.5.0"
+      expect(@provider).to receive(:selmodversion_loaded).and_return("1.4.0")
+      expect(@provider).to receive(:selmodversion_file).and_return("1.5.0")
       expect(@provider.syncversion).to eq(:false)
     end
 
     it "should return before checking file version if no loaded policy" do
-      @provider.expects(:selmodversion_loaded).returns nil
+      expect(@provider).to receive(:selmodversion_loaded).and_return(nil)
       expect(@provider.syncversion).to eq(:false)
     end
   end
 
   describe "selmodversion_loaded" do
     it "should return the version of a loaded module" do
-      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields StringIO.new("bar\t1.2.3\nfoo\t4.4.4\nbang\t1.0.0\n")
+      expect(@provider).to receive(:command).with(:semodule).and_return("/usr/sbin/semodule")
+      expect(@provider).to receive(:execpipe).with("/usr/sbin/semodule --list").and_yield(StringIO.new("bar\t1.2.3\nfoo\t4.4.4\nbang\t1.0.0\n"))
       expect(@provider.selmodversion_loaded).to eq("4.4.4")
     end
 
     it 'should return raise an exception when running selmodule raises an exception' do
-      @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-      @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields("this is\nan error").raises(Puppet::ExecutionFailure, 'it failed')
+      expect(@provider).to receive(:command).with(:semodule).and_return("/usr/sbin/semodule")
+      expect(@provider).to receive(:execpipe).with("/usr/sbin/semodule --list").and_yield("this is\nan error").and_raise(Puppet::ExecutionFailure, 'it failed')
       expect {@provider.selmodversion_loaded}.to raise_error(Puppet::ExecutionFailure, /Could not list policy modules: ".*" failed with "this is an error"/)
     end
   end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'rbconfig'
 require 'fileutils'
@@ -41,7 +40,7 @@ describe "base service provider" do
         return 'started'
       when status_command
         expect(options[:failonfail]).to eq(false)
-        $CHILD_STATUS.expects(:exitstatus).at_least(1).returns(@running ? 0 : 1)
+        allow($CHILD_STATUS).to receive(:exitstatus) {@running ? 0 : 1}
         return @running ? 'running' : 'not running'
       when stop_command
         expect(options[:failonfail]).to eq(true)
@@ -55,7 +54,7 @@ describe "base service provider" do
 
     before :each do
       @running = false
-      executor.expects(:execute).at_least(1).with { |command, options| execute_command(command, options) }
+      expect(executor).to receive(:execute).at_least(:once) { |command, options| execute_command(command, options) }
     end
 
     it "should invoke the start command if not running" do
@@ -101,10 +100,10 @@ describe "base service provider" do
     end
 
     it "retrieves a PID from the process table" do
-      Facter.stubs(:value).with(:operatingsystem).returns("CentOS")
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return("CentOS")
       ps_output = File.binread(my_fixture("ps_ef.mixed_encoding")).force_encoding(Encoding::UTF_8)
 
-      executor.expects(:execute).with("ps -ef").returns(ps_output)
+      expect(executor).to receive(:execute).with("ps -ef").and_return(ps_output)
 
       expect(subject.status).to eq(:running)
     end

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

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:bsd), :unless => Puppet.features.microsoft_windows? do
   before :each do
-    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
-    Facter.stubs(:value).with(:operatingsystem).returns :netbsd
-    Facter.stubs(:value).with(:osfamily).returns 'NetBSD'
-    described_class.stubs(:defpath).returns('/etc/rc.conf.d')
+    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(described_class)
+    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:netbsd)
+    allow(Facter).to receive(:value).with(:osfamily).and_return('NetBSD')
+    allow(described_class).to receive(:defpath).and_return('/etc/rc.conf.d')
     @provider = subject()
-    @provider.stubs(:initscript)
+    allow(@provider).to receive(:initscript)
   end
 
   context "#instances" do
@@ -27,16 +27,16 @@ describe Puppet::Type.type(:service).provider(:bsd), :unless => Puppet.features.
 
     it "should remove a service file to disable" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
-      Puppet::FileSystem.expects(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
-      File.stubs(:delete).with('/etc/rc.conf.d/sshd')
+      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(true)
+      expect(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(true)
+      allow(File).to receive(:delete).with('/etc/rc.conf.d/sshd')
       provider.disable
     end
 
     it "should not remove a service file if it doesn't exist" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      File.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
-      Puppet::FileSystem.expects(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
+      allow(File).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(false)
+      expect(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(false)
       provider.disable
     end
   end
@@ -48,20 +48,20 @@ describe Puppet::Type.type(:service).provider(:bsd), :unless => Puppet.features.
 
     it "should set the proper contents to enable" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      Dir.stubs(:mkdir).with('/etc/rc.conf.d')
-      fh = stub 'fh'
-      File.stubs(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).yields(fh)
-      fh.expects(:<<).with("sshd_enable=\"YES\"\n")
+      allow(Dir).to receive(:mkdir).with('/etc/rc.conf.d')
+      fh = double('fh')
+      allow(File).to receive(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).and_yield(fh)
+      expect(fh).to receive(:<<).with("sshd_enable=\"YES\"\n")
       provider.enable
     end
 
     it "should set the proper contents to enable when disabled" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      Dir.stubs(:mkdir).with('/etc/rc.conf.d')
-      File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"NO\"\n")
-      fh = stub 'fh'
-      File.stubs(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).yields(fh)
-      fh.expects(:<<).with("sshd_enable=\"YES\"\n")
+      allow(Dir).to receive(:mkdir).with('/etc/rc.conf.d')
+      allow(File).to receive(:read).with('/etc/rc.conf.d/sshd').and_return("sshd_enable=\"NO\"\n")
+      fh = double('fh')
+      allow(File).to receive(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).and_yield(fh)
+      expect(fh).to receive(:<<).with("sshd_enable=\"YES\"\n")
       provider.enable
     end
   end
@@ -73,15 +73,13 @@ describe Puppet::Type.type(:service).provider(:bsd), :unless => Puppet.features.
 
     it "should return false if the service file does not exist" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
-      # File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"NO\"\n")
+      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(false)
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return true if the service file exists" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
-      # File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"YES\"\n")
+      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(true)
       expect(provider.enabled?).to eq(:true)
     end
   end
@@ -93,14 +91,14 @@ describe Puppet::Type.type(:service).provider(:bsd), :unless => Puppet.features.
 
     it "should use the supplied start command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
 
     it "should start the serviced directly otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', :onestart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      expect(provider).to receive(:execute).with(['/etc/rc.d/sshd', :onestart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:search).with('sshd').and_return('/etc/rc.d/sshd')
       provider.start
     end
   end
@@ -112,14 +110,14 @@ describe Puppet::Type.type(:service).provider(:bsd), :unless => Puppet.features.
 
     it "should use the supplied stop command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
 
     it "should stop the serviced directly otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', :onestop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      expect(provider).to receive(:execute).with(['/etc/rc.d/sshd', :onestop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:search).with('sshd').and_return('/etc/rc.d/sshd')
       provider.stop
     end
   end

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Puppet::Type.type(:service).provider(:daemontools) do
   before(:each) do
     # Create a mock resource
-    @resource = stub 'resource'
+    @resource = double('resource')
 
     @provider = subject()
     @servicedir = "/etc/service"
@@ -12,22 +12,22 @@ describe Puppet::Type.type(:service).provider(:daemontools) do
     @provider.class.defpath=@daemondir
 
     # A catch all; no parameters set
-    @resource.stubs(:[]).returns(nil)
+    allow(@resource).to receive(:[]).and_return(nil)
 
     # But set name, source and path (because we won't run
     # the thing that will fetch the resource path from the provider)
-    @resource.stubs(:[]).with(:name).returns "myservice"
-    @resource.stubs(:[]).with(:ensure).returns :enabled
-    @resource.stubs(:[]).with(:path).returns @daemondir
-    @resource.stubs(:ref).returns "Service[myservice]"
+    allow(@resource).to receive(:[]).with(:name).and_return("myservice")
+    allow(@resource).to receive(:[]).with(:ensure).and_return(:enabled)
+    allow(@resource).to receive(:[]).with(:path).and_return(@daemondir)
+    allow(@resource).to receive(:ref).and_return("Service[myservice]")
 
     @provider.resource = @resource
 
-    @provider.stubs(:command).with(:svc).returns "svc"
-    @provider.stubs(:command).with(:svstat).returns "svstat"
+    allow(@provider).to receive(:command).with(:svc).and_return("svc")
+    allow(@provider).to receive(:command).with(:svstat).and_return("svstat")
 
-    @provider.stubs(:svc)
-    @provider.stubs(:svstat)
+    allow(@provider).to receive(:svc)
+    allow(@provider).to receive(:svstat)
   end
 
   it "should have a restart method" do
@@ -56,17 +56,17 @@ describe Puppet::Type.type(:service).provider(:daemontools) do
 
   context "when starting" do
     it "should use 'svc' to start the service" do
-      @provider.stubs(:enabled?).returns :true
-      @provider.expects(:svc).with("-u", "/etc/service/myservice")
+      allow(@provider).to receive(:enabled?).and_return(:true)
+      expect(@provider).to receive(:svc).with("-u", "/etc/service/myservice")
 
       @provider.start
     end
 
     it "should enable the service if it is not enabled" do
-      @provider.stubs(:svc)
+      allow(@provider).to receive(:svc)
 
-      @provider.expects(:enabled?).returns :false
-      @provider.expects(:enable)
+      expect(@provider).to receive(:enabled?).and_return(:false)
+      expect(@provider).to receive(:enable)
 
       @provider.start
     end
@@ -74,8 +74,8 @@ describe Puppet::Type.type(:service).provider(:daemontools) do
 
   context "when stopping" do
     it "should use 'svc' to stop the service" do
-      @provider.stubs(:disable)
-      @provider.expects(:svc).with("-d", "/etc/service/myservice")
+      allow(@provider).to receive(:disable)
+      expect(@provider).to receive(:svc).with("-d", "/etc/service/myservice")
 
       @provider.stop
     end
@@ -83,7 +83,7 @@ describe Puppet::Type.type(:service).provider(:daemontools) do
 
   context "when restarting" do
     it "should use 'svc' to restart the service" do
-      @provider.expects(:svc).with("-t", "/etc/service/myservice")
+      expect(@provider).to receive(:svc).with("-t", "/etc/service/myservice")
 
       @provider.restart
     end
@@ -93,8 +93,8 @@ describe Puppet::Type.type(:service).provider(:daemontools) do
     it "should create a symlink between daemon dir and service dir", :if => Puppet.features.manages_symlinks?  do
       daemon_path = File.join(@daemondir, "myservice")
       service_path = File.join(@servicedir, "myservice")
-      Puppet::FileSystem.expects(:symlink?).with(service_path).returns(false)
-      Puppet::FileSystem.expects(:symlink).with(daemon_path, service_path).returns(0)
+      expect(Puppet::FileSystem).to receive(:symlink?).with(service_path).and_return(false)
+      expect(Puppet::FileSystem).to receive(:symlink).with(daemon_path, service_path).and_return(0)
 
       @provider.enable
     end
@@ -102,35 +102,35 @@ describe Puppet::Type.type(:service).provider(:daemontools) do
 
   context "when disabling" do
     it "should remove the symlink between daemon dir and service dir" do
-      FileTest.stubs(:directory?).returns(false)
+      allow(FileTest).to receive(:directory?).and_return(false)
       path = File.join(@servicedir,"myservice")
-      Puppet::FileSystem.expects(:symlink?).with(path).returns(true)
-      Puppet::FileSystem.expects(:unlink).with(path)
-      @provider.stubs(:texecute).returns("")
+      expect(Puppet::FileSystem).to receive(:symlink?).with(path).and_return(true)
+      expect(Puppet::FileSystem).to receive(:unlink).with(path)
+      allow(@provider).to receive(:texecute).and_return("")
       @provider.disable
     end
 
     it "should stop the service" do
-      FileTest.stubs(:directory?).returns(false)
-      Puppet::FileSystem.expects(:symlink?).returns(true)
-      Puppet::FileSystem.stubs(:unlink)
-      @provider.expects(:stop)
+      allow(FileTest).to receive(:directory?).and_return(false)
+      expect(Puppet::FileSystem).to receive(:symlink?).and_return(true)
+      allow(Puppet::FileSystem).to receive(:unlink)
+      expect(@provider).to receive(:stop)
       @provider.disable
     end
   end
 
   context "when checking if the service is enabled?" do
     it "should return true if it is running" do
-      @provider.stubs(:status).returns(:running)
+      allow(@provider).to receive(:status).and_return(:running)
 
       expect(@provider.enabled?).to eq(:true)
     end
 
     [true, false].each do |t|
       it "should return #{t} if the symlink exists" do
-        @provider.stubs(:status).returns(:stopped)
+        allow(@provider).to receive(:status).and_return(:stopped)
         path = File.join(@servicedir,"myservice")
-        Puppet::FileSystem.expects(:symlink?).with(path).returns(t)
+        expect(Puppet::FileSystem).to receive(:symlink?).with(path).and_return(t)
 
         expect(@provider.enabled?).to eq("#{t}".to_sym)
       end
@@ -139,24 +139,24 @@ describe Puppet::Type.type(:service).provider(:daemontools) do
 
   context "when checking status" do
     it "should call the external command 'svstat /etc/service/myservice'" do
-      @provider.expects(:svstat).with(File.join(@servicedir,"myservice"))
+      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice"))
       @provider.status
     end
   end
 
   context "when checking status" do
     it "and svstat fails, properly raise a Puppet::Error" do
-      @provider.expects(:svstat).with(File.join(@servicedir,"myservice")).raises(Puppet::ExecutionFailure, "failure")
+      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice")).and_raise(Puppet::ExecutionFailure, "failure")
       expect { @provider.status }.to raise_error(Puppet::Error, 'Could not get status for service Service[myservice]: failure')
     end
 
     it "and svstat returns up, then return :running" do
-      @provider.expects(:svstat).with(File.join(@servicedir,"myservice")).returns("/etc/service/myservice: up (pid 454) 954326 seconds")
+      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice")).and_return("/etc/service/myservice: up (pid 454) 954326 seconds")
       expect(@provider.status).to eq(:running)
     end
 
     it "and svstat returns not running, then return :stopped" do
-      @provider.expects(:svstat).with(File.join(@servicedir,"myservice")).returns("/etc/service/myservice: supervise not running")
+      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice")).and_return("/etc/service/myservice: supervise not running")
       expect(@provider.status).to  eq(:stopped)
     end
   end