puppet 5.5.12 → 5.5.13

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

@@ -1,62 +1,56 @@
-#! /usr/bin/env ruby
-#
-# Unit testing for the OpenWrt service Provider
-#
 require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:openwrt), :if => Puppet.features.posix? do
-
   let(:resource) do
-    resource = stub 'resource'
-    resource.stubs(:[]).returns(nil)
-    resource.stubs(:[]).with(:name).returns "myservice"
-    resource.stubs(:[]).with(:path).returns ["/etc/init.d"]
+    resource = double('resource')
+    allow(resource).to receive(:[]).and_return(nil)
+    allow(resource).to receive(:[]).with(:name).and_return("myservice")
+    allow(resource).to receive(:[]).with(:path).and_return(["/etc/init.d"])
 
     resource
   end
 
   let(:provider) do
     provider = described_class.new
-    provider.stubs(:get).with(:hasstatus).returns false
+    allow(provider).to receive(:get).with(:hasstatus).and_return(false)
 
     provider
   end
 
-
   before :each do
-    resource.stubs(:provider).returns provider
+    allow(resource).to receive(:provider).and_return(provider)
     provider.resource = resource
 
-    FileTest.stubs(:file?).with('/etc/rc.common').returns true
-    FileTest.stubs(:executable?).with('/etc/rc.common').returns true
+    allow(FileTest).to receive(:file?).with('/etc/rc.common').and_return(true)
+    allow(FileTest).to receive(:executable?).with('/etc/rc.common').and_return(true)
 
     # All OpenWrt tests operate on the init script directly. It must exist.
-    File.stubs(:directory?).with('/etc/init.d').returns true
+    allow(File).to receive(:directory?).with('/etc/init.d').and_return(true)
 
-    Puppet::FileSystem.stubs(:exist?).with('/etc/init.d/myservice').returns true
-    FileTest.stubs(:file?).with('/etc/init.d/myservice').returns true
-    FileTest.stubs(:executable?).with('/etc/init.d/myservice').returns true
+    allow(Puppet::FileSystem).to receive(:exist?).with('/etc/init.d/myservice').and_return(true)
+    allow(FileTest).to receive(:file?).with('/etc/init.d/myservice').and_return(true)
+    allow(FileTest).to receive(:executable?).with('/etc/init.d/myservice').and_return(true)
   end
 
   operatingsystem = 'openwrt'
   it "should be the default provider on #{operatingsystem}" do
-    Facter.expects(:value).with(:operatingsystem).returns(operatingsystem)
+    expect(Facter).to receive(:value).with(:operatingsystem).and_return(operatingsystem)
     expect(described_class.default?).to be_truthy
   end
 
   # test self.instances
   describe "when getting all service instances" do
-
     let(:services) {['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ]}
 
     before :each do
-      Dir.stubs(:entries).returns services
-      FileTest.stubs(:directory?).returns(true)
-      FileTest.stubs(:executable?).returns(true)
+      allow(Dir).to receive(:entries).and_return(services)
+      allow(FileTest).to receive(:directory?).and_return(true)
+      allow(FileTest).to receive(:executable?).and_return(true)
     end
+
     it "should return instances for all services" do
       services.each do |inst|
-        described_class.expects(:new).with{|hash| hash[:name] == inst && hash[:path] == '/etc/init.d'}.returns("#{inst}_instance")
+        expect(described_class).to receive(:new).with(hash_including(name: inst, path: '/etc/init.d')).and_return("#{inst}_instance")
       end
       results = services.collect {|x| "#{x}_instance"}
       expect(described_class.instances).to eq(results)
@@ -79,17 +73,17 @@ describe Puppet::Type.type(:service).provider(:openwrt), :if => Puppet.features.
     it "should have a #{method} method" do
       expect(provider).to respond_to(method)
     end
-    describe "when running #{method}" do
 
+    describe "when running #{method}" do
       it "should use any provided explicit command" do
-        resource.stubs(:[]).with(method).returns "/user/specified/command"
-        provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
+        allow(resource).to receive(:[]).with(method).and_return("/user/specified/command")
+        expect(provider).to receive(:execute).with(["/user/specified/command"], any_args)
         provider.send(method)
       end
 
       it "should execute the init script with #{method} when no explicit command is provided" do
-        resource.stubs(:[]).with("has#{method}".intern).returns :true
-        provider.expects(:execute).with { |command, *args| command ==  ['/etc/init.d/myservice', method ]}
+        allow(resource).to receive(:[]).with("has#{method}".intern).and_return(:true)
+        expect(provider).to receive(:execute).with(['/etc/init.d/myservice', method ], any_args)
         provider.send(method)
       end
     end
@@ -97,13 +91,13 @@ describe Puppet::Type.type(:service).provider(:openwrt), :if => Puppet.features.
 
   describe "when checking status" do
     it "should consider the service :running if it has a pid" do
-      provider.expects(:getpid).returns "1234"
+      expect(provider).to receive(:getpid).and_return("1234")
       expect(provider.status).to eq(:running)
     end
+
     it "should consider the service :stopped if it doesn't have a pid" do
-      provider.expects(:getpid).returns nil
+      expect(provider).to receive(:getpid).and_return(nil)
       expect(provider.status).to eq(:stopped)
     end
   end
-
 end

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

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:rcng), :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.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.d')
     @provider = subject()
-    @provider.stubs(:initscript)
+    allow(@provider).to receive(:initscript)
   end
 
   context "#enable" do
@@ -17,20 +17,20 @@ describe Puppet::Type.type(:service).provider(:rcng), :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'
-      Puppet::Util.expects(:replace_file).with('/etc/rc.conf.d/sshd', 0644).yields(fh)
-      fh.expects(:puts).with("sshd=${sshd:=YES}\n")
+      allow(Dir).to receive(:mkdir).with('/etc/rc.conf.d')
+      fh = double('fh')
+      expect(Puppet::Util).to receive(:replace_file).with('/etc/rc.conf.d/sshd', 0644).and_yield(fh)
+      expect(fh).to receive(:puts).with("sshd=${sshd:=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'
-      Puppet::Util.expects(:replace_file).with('/etc/rc.conf.d/sshd', 0644).yields(fh)
-      fh.expects(:puts).with("sshd=${sshd:=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')
+      expect(Puppet::Util).to receive(:replace_file).with('/etc/rc.conf.d/sshd', 0644).and_yield(fh)
+      expect(fh).to receive(:puts).with("sshd=${sshd:=YES}\n")
       provider.enable
     end
   end

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

@@ -3,32 +3,32 @@ require 'spec_helper'
 describe Puppet::Type.type(:service).provider(:redhat), :if => Puppet.features.posix? do
   before :each do
     @class = Puppet::Type.type(:service).provider(:redhat)
-    @resource = stub 'resource'
-    @resource.stubs(:[]).returns(nil)
-    @resource.stubs(:[]).with(:name).returns "myservice"
+    @resource = double('resource')
+    allow(@resource).to receive(:[]).and_return(nil)
+    allow(@resource).to receive(:[]).with(:name).and_return("myservice")
     @provider = subject()
-    @resource.stubs(:provider).returns @provider
+    allow(@resource).to receive(:provider).and_return(@provider)
     @provider.resource = @resource
-    @provider.stubs(:get).with(:hasstatus).returns false
-    FileTest.stubs(:file?).with('/sbin/service').returns true
-    FileTest.stubs(:executable?).with('/sbin/service').returns true
-    Facter.stubs(:value).with(:operatingsystem).returns('CentOS')
-    Facter.stubs(:value).with(:osfamily).returns 'RedHat'
+    allow(@provider).to receive(:get).with(:hasstatus).and_return(false)
+    allow(FileTest).to receive(:file?).with('/sbin/service').and_return(true)
+    allow(FileTest).to receive(:executable?).with('/sbin/service').and_return(true)
+    allow(Facter).to receive(:value).with(:operatingsystem).and_return('CentOS')
+    allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
   end
 
   osfamilies = [ 'RedHat' ]
 
   osfamilies.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
-      Facter.expects(:value).with(:osfamily).returns(osfamily)
+      expect(Facter).to receive(:value).with(:osfamily).and_return(osfamily)
       expect(described_class.default?).to be_truthy
     end
   end
 
   it "should be the default provider on sles11" do
-    Facter.stubs(:value).with(:osfamily).returns(:suse)
-    Facter.stubs(:value).with(:operatingsystem).returns(:suse)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("11")
+    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
+    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:suse)
+    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("11")
     expect(described_class.default?).to be_truthy
   end
 
@@ -37,33 +37,35 @@ describe Puppet::Type.type(:service).provider(:redhat), :if => Puppet.features.p
     before :each do
       @services = ['one', 'two', 'three', 'four', 'kudzu', 'functions', 'halt', 'killall', 'single', 'linuxconf', 'boot', 'reboot']
       @not_services = ['functions', 'halt', 'killall', 'single', 'linuxconf', 'reboot', 'boot']
-      Dir.stubs(:entries).returns @services
-      FileTest.stubs(:directory?).returns(true)
-      FileTest.stubs(:executable?).returns(true)
+      allow(Dir).to receive(:entries).and_return(@services)
+      allow(FileTest).to receive(:directory?).and_return(true)
+      allow(FileTest).to receive(:executable?).and_return(true)
     end
+
     it "should return instances for all services" do
       (@services-@not_services).each do |inst|
-        @class.expects(:new).with{|hash| hash[:name] == inst && hash[:path] == '/etc/init.d'}.returns("#{inst}_instance")
+        expect(@class).to receive(:new).with(hash_including(name: inst, path: '/etc/init.d')).and_return("#{inst}_instance")
       end
       results = (@services-@not_services).collect {|x| "#{x}_instance"}
       expect(@class.instances).to eq(results)
     end
+
     it "should call service status when initialized from provider" do
-      @resource.stubs(:[]).with(:status).returns nil
-      @provider.stubs(:get).with(:hasstatus).returns true
-      @provider.expects(:execute).with{|command, *args| command == ['/sbin/service', 'myservice', 'status']}
+      allow(@resource).to receive(:[]).with(:status).and_return(nil)
+      allow(@provider).to receive(:get).with(:hasstatus).and_return(true)
+      expect(@provider).to receive(:execute).with(['/sbin/service', 'myservice', 'status'], any_args)
       @provider.send(:status)
     end
   end
 
   it "should use '--add' and 'on' when calling enable" do
-    described_class.expects(:chkconfig).with("--add", @resource[:name])
-    described_class.expects(:chkconfig).with(@resource[:name], :on)
+    expect(described_class).to receive(:chkconfig).with("--add", @resource[:name])
+    expect(described_class).to receive(:chkconfig).with(@resource[:name], :on)
     @provider.enable
   end
 
   it "(#15797) should explicitly turn off the service in all run levels" do
-    described_class.expects(:chkconfig).with("--level", "0123456", @resource[:name], :off)
+    expect(described_class).to receive(:chkconfig).with("--level", "0123456", @resource[:name], :off)
     @provider.disable
   end
 
@@ -73,26 +75,26 @@ describe Puppet::Type.type(:service).provider(:redhat), :if => Puppet.features.p
 
   context "when checking enabled? on Suse" do
     before :each do
-      Facter.expects(:value).with(:osfamily).returns 'Suse'
+      expect(Facter).to receive(:value).with(:osfamily).and_return('Suse')
     end
 
     it "should check for on" do
-      described_class.stubs(:chkconfig).with(@resource[:name]).returns "#{@resource[:name]}  on"
+      allow(described_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}  on")
       expect(@provider.enabled?).to eq(:true)
     end
 
     it "should check for B" do
-      described_class.stubs(:chkconfig).with(@resource[:name]).returns "#{@resource[:name]}  B"
+      allow(described_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}  B")
       expect(@provider.enabled?).to eq(:true)
     end
 
     it "should check for off" do
-      described_class.stubs(:chkconfig).with(@resource[:name]).returns "#{@resource[:name]}  off"
+      allow(described_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}  off")
       expect(@provider.enabled?).to eq(:false)
     end
 
     it "should check for unknown service" do
-      described_class.stubs(:chkconfig).with(@resource[:name]).returns "#{@resource[:name]}: unknown service"
+      allow(described_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}: unknown service")
       expect(@provider.enabled?).to eq(:false)
     end
   end
@@ -109,17 +111,17 @@ describe Puppet::Type.type(:service).provider(:redhat), :if => Puppet.features.p
     it "should have a #{method} method" do
       expect(@provider).to respond_to(method)
     end
-    describe "when running #{method}" do
 
+    describe "when running #{method}" do
       it "should use any provided explicit command" do
-        @resource.stubs(:[]).with(method).returns "/user/specified/command"
-        @provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
+        allow(@resource).to receive(:[]).with(method).and_return("/user/specified/command")
+        expect(@provider).to receive(:execute).with(["/user/specified/command"], any_args)
         @provider.send(method)
       end
 
       it "should execute the service script with #{method} when no explicit command is provided" do
-        @resource.stubs(:[]).with("has#{method}".intern).returns :true
-        @provider.expects(:execute).with { |command, *args| command ==  ['/sbin/service', 'myservice', method.to_s]}
+        allow(@resource).to receive(:[]).with("has#{method}".intern).and_return(:true)
+        expect(@provider).to receive(:execute).with(['/sbin/service', 'myservice', method.to_s], any_args)
         @provider.send(method)
       end
     end
@@ -128,24 +130,24 @@ describe Puppet::Type.type(:service).provider(:redhat), :if => Puppet.features.p
   context "when checking status" do
     context "when hasstatus is :true" do
       before :each do
-        @resource.stubs(:[]).with(:hasstatus).returns :true
+        allow(@resource).to receive(:[]).with(:hasstatus).and_return(:true)
       end
 
       it "should execute the service script with fail_on_failure false" do
-        @provider.expects(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
+        expect(@provider).to receive(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
         @provider.status
       end
 
       it "should consider the process running if the command returns 0" do
-        @provider.expects(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
-        $CHILD_STATUS.stubs(:exitstatus).returns(0)
+        expect(@provider).to receive(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
+        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
         expect(@provider.status).to eq(:running)
       end
 
       [-10,-1,1,10].each { |ec|
         it "should consider the process stopped if the command returns something non-0" do
-          @provider.expects(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
-          $CHILD_STATUS.stubs(:exitstatus).returns(ec)
+          expect(@provider).to receive(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
+          allow($CHILD_STATUS).to receive(:exitstatus).and_return(ec)
           expect(@provider.status).to eq(:stopped)
         end
       }
@@ -153,12 +155,12 @@ describe Puppet::Type.type(:service).provider(:redhat), :if => Puppet.features.p
 
     context "when hasstatus is not :true" do
       it "should consider the service :running if it has a pid" do
-        @provider.expects(:getpid).returns "1234"
+        expect(@provider).to receive(:getpid).and_return("1234")
         expect(@provider.status).to eq(:running)
       end
 
       it "should consider the service :stopped if it doesn't have a pid" do
-        @provider.expects(:getpid).returns nil
+        expect(@provider).to receive(:getpid).and_return(nil)
         expect(@provider.status).to eq(:stopped)
       end
     end
@@ -166,8 +168,8 @@ describe Puppet::Type.type(:service).provider(:redhat), :if => Puppet.features.p
 
   context "when restarting and hasrestart is not :true" do
     it "should stop and restart the process with the server script" do
-      @provider.expects(:texecute).with(:stop,  ['/sbin/service', 'myservice', 'stop'],  true)
-      @provider.expects(:texecute).with(:start, ['/sbin/service', 'myservice', 'start'], true)
+      expect(@provider).to receive(:texecute).with(:stop,  ['/sbin/service', 'myservice', 'stop'],  true)
+      expect(@provider).to receive(:texecute).with(:start, ['/sbin/service', 'myservice', 'start'], true)
       @provider.restart
     end
   end

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Puppet::Type.type(:service).provider(:runit) do
   before(:each) do
     # Create a mock resource
-    @resource = stub 'resource'
+    @resource = double('resource')
 
     @provider = subject()
     @servicedir = "/etc/service"
@@ -12,18 +12,18 @@ describe Puppet::Type.type(:service).provider(:runit) 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.stubs(:sv)
+    allow(@provider).to receive(:sv)
 
-    @provider.stubs(:resource).returns @resource
+    allow(@provider).to receive(:resource).and_return(@resource)
   end
 
   it "should have a restart method" do
@@ -56,32 +56,32 @@ describe Puppet::Type.type(:service).provider(:runit) do
 
   context "when starting" do
     it "should enable the service if it is not enabled" do
-      @provider.stubs(:sv)
+      allow(@provider).to receive(:sv)
 
-      @provider.expects(:enabled?).returns :false
-      @provider.expects(:enable)
-      @provider.stubs(:sleep)
+      expect(@provider).to receive(:enabled?).and_return(:false)
+      expect(@provider).to receive(:enable)
+      allow(@provider).to receive(:sleep)
 
       @provider.start
     end
 
     it "should execute external command 'sv start /etc/service/myservice'" do
-      @provider.stubs(:enabled?).returns :true
-      @provider.expects(:sv).with("start", "/etc/service/myservice")
+      allow(@provider).to receive(:enabled?).and_return(:true)
+      expect(@provider).to receive(:sv).with("start", "/etc/service/myservice")
       @provider.start
     end
   end
 
   context "when stopping" do
     it "should execute external command 'sv stop /etc/service/myservice'" do
-      @provider.expects(:sv).with("stop", "/etc/service/myservice")
+      expect(@provider).to receive(:sv).with("stop", "/etc/service/myservice")
       @provider.stop
     end
   end
 
   context "when restarting" do
     it "should call 'sv restart /etc/service/myservice'" do
-      @provider.expects(:sv).with("restart","/etc/service/myservice")
+      expect(@provider).to receive(:sv).with("restart","/etc/service/myservice")
       @provider.restart
     end
   end
@@ -90,8 +90,8 @@ describe Puppet::Type.type(:service).provider(:runit) 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, File.join(@servicedir,"myservice")).returns(0)
+      expect(Puppet::FileSystem).to receive(:symlink?).with(service_path).and_return(false)
+      expect(Puppet::FileSystem).to receive(:symlink).with(daemon_path, File.join(@servicedir,"myservice")).and_return(0)
       @provider.enable
     end
   end
@@ -99,36 +99,38 @@ describe Puppet::Type.type(:service).provider(:runit) do
   context "when disabling" do
     it "should remove the '/etc/service/myservice' symlink" do
       path = File.join(@servicedir,"myservice")
-#      mocked_file = mock(path, :symlink? => true)
-      FileTest.stubs(:directory?).returns(false)
-      Puppet::FileSystem.expects(:symlink?).with(path).returns(true) # mocked_file)
-      Puppet::FileSystem.expects(:unlink).with(path).returns(0)
+      allow(FileTest).to receive(:directory?).and_return(false)
+      expect(Puppet::FileSystem).to receive(:symlink?).with(path).and_return(true)
+      expect(Puppet::FileSystem).to receive(:unlink).with(path).and_return(0)
       @provider.disable
     end
   end
 
   context "when checking status" do
     it "should call the external command 'sv status /etc/sv/myservice'" do
-      @provider.expects(:sv).with('status',File.join(@daemondir,"myservice"))
+      expect(@provider).to receive(:sv).with('status',File.join(@daemondir,"myservice"))
       @provider.status
     end
   end
 
   context "when checking status" do
     it "and sv status fails, properly raise a Puppet::Error" do
-      @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).raises(Puppet::ExecutionFailure, "fail: /etc/sv/myservice: file not found")
+      expect(@provider).to receive(:sv).with('status',File.join(@daemondir,"myservice")).and_raise(Puppet::ExecutionFailure, "fail: /etc/sv/myservice: file not found")
       expect { @provider.status }.to raise_error(Puppet::Error, 'Could not get status for service Service[myservice]: fail: /etc/sv/myservice: file not found')
     end
+
     it "and sv status returns up, then return :running" do
-      @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("run: /etc/sv/myservice: (pid 9029) 6s")
+      expect(@provider).to receive(:sv).with('status',File.join(@daemondir,"myservice")).and_return("run: /etc/sv/myservice: (pid 9029) 6s")
       expect(@provider.status).to eq(:running)
     end
+
     it "and sv status returns not running, then return :stopped" do
-      @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("fail: /etc/sv/myservice: runsv not running")
+      expect(@provider).to receive(:sv).with('status',File.join(@daemondir,"myservice")).and_return("fail: /etc/sv/myservice: runsv not running")
       expect(@provider.status).to eq(:stopped)
     end
+
     it "and sv status returns a warning, then return :stopped" do
-      @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("warning: /etc/sv/myservice: unable to open supervise/ok: file does not exist")
+      expect(@provider).to receive(:sv).with('status',File.join(@daemondir,"myservice")).and_return("warning: /etc/sv/myservice: unable to open supervise/ok: file does not exist")
       expect(@provider.status).to eq(:stopped)
     end
   end