puppet 6.0.7-x64-mingw32 → 6.0.8-x64-mingw32

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

@@ -10,13 +10,13 @@ describe 'Puppet::Type::Service::Provider::Smf',
       :name => "/system/myservice", :ensure => :running, :enable => :true)
     @provider = provider_class.new(@resource)
 
-    FileTest.stubs(:file?).with('/usr/sbin/svcadm').returns true
-    FileTest.stubs(:executable?).with('/usr/sbin/svcadm').returns true
-    FileTest.stubs(:file?).with('/usr/bin/svcs').returns true
-    FileTest.stubs(:executable?).with('/usr/bin/svcs').returns true
-    Facter.stubs(:value).with(:operatingsystem).returns('Solaris')
-    Facter.stubs(:value).with(:osfamily).returns('Solaris')
-    Facter.stubs(:value).with(:operatingsystemrelease).returns '11.2'
+    allow(FileTest).to receive(:file?).with('/usr/sbin/svcadm').and_return(true)
+    allow(FileTest).to receive(:executable?).with('/usr/sbin/svcadm').and_return(true)
+    allow(FileTest).to receive(:file?).with('/usr/bin/svcs').and_return(true)
+    allow(FileTest).to receive(:executable?).with('/usr/bin/svcs').and_return(true)
+    allow(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
+    allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
+    allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.2')
   end
 
   context ".instances" do
@@ -25,7 +25,7 @@ describe 'Puppet::Type::Service::Provider::Smf',
     end
 
     it "should get a list of services (excluding legacy)" do
-      provider_class.expects(:svcs).with('-H', '-o', 'state,fmri').returns File.read(my_fixture('svcs.out'))
+      expect(provider_class).to receive(:svcs).with('-H', '-o', 'state,fmri').and_return(File.read(my_fixture('svcs.out')))
       instances = provider_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
       # we dont manage legacy
       expect(instances.size).to eq(3)
@@ -65,81 +65,89 @@ describe 'Puppet::Type::Service::Provider::Smf',
 
   describe "when checking status" do
     before(:each) do
-      @provider.stubs(:complete_service?).returns(true)
+      allow(@provider).to receive(:complete_service?).and_return(true)
     end
 
     it "should call the external command 'svcs /system/myservice' once" do
-      @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
+      expect(@provider).to receive(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").and_return("online\t-")
       @provider.status
     end
+
     it "should return stopped if svcs can't find the service" do
-      @provider.stubs(:svcs).raises(Puppet::ExecutionFailure.new("no svc found"))
+      allow(@provider).to receive(:svcs).and_raise(Puppet::ExecutionFailure.new("no svc found"))
       expect(@provider.status).to eq(:stopped)
     end
+
     it "should return stopped for an incomplete service on Solaris 11" do
-      Facter.stubs(:value).with(:operatingsystemrelease).returns('11.3')
-      @provider.stubs(:complete_service?).returns(false)
+      allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.3')
+      allow(@provider).to receive(:complete_service?).and_return(false)
       expect(@provider.status).to eq(:stopped)
     end
+
     it "should return running if online in svcs output" do
-      @provider.stubs(:svcs).returns("online\t-")
+      allow(@provider).to receive(:svcs).and_return("online\t-")
       expect(@provider.status).to eq(:running)
     end
+
     it "should return stopped if disabled in svcs output" do
-      @provider.stubs(:svcs).returns("disabled\t-")
+      allow(@provider).to receive(:svcs).and_return("disabled\t-")
       expect(@provider.status).to eq(:stopped)
     end
+
     it "should return maintenance if in maintenance in svcs output" do
-      @provider.stubs(:svcs).returns("maintenance\t-")
+      allow(@provider).to receive(:svcs).and_return("maintenance\t-")
       expect(@provider.status).to eq(:maintenance)
     end
+
     it "should return degraded if in degraded in svcs output" do
-      @provider.stubs(:svcs).returns("degraded\t-")
+      allow(@provider).to receive(:svcs).and_return("degraded\t-")
       expect(@provider.status).to eq(:degraded)
     end
+
     it "should return target state if transitioning in svcs output" do
-      @provider.stubs(:svcs).returns("online\tdisabled")
+      allow(@provider).to receive(:svcs).and_return("online\tdisabled")
       expect(@provider.status).to eq(:stopped)
     end
+
     it "should throw error if it's a legacy service in svcs output" do
-      @provider.stubs(:svcs).returns("legacy_run\t-")
+      allow(@provider).to receive(:svcs).and_return("legacy_run\t-")
       expect { @provider.status }.to raise_error(Puppet::Error, "Cannot manage legacy services through SMF")
     end
   end
 
   context "when starting" do
     it "should enable the service if it is not enabled" do
-      @provider.expects(:status).returns :stopped
-      @provider.expects(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-rs', '/system/myservice'], true)
-      @provider.expects(:wait).with('online')
+      expect(@provider).to receive(:status).and_return(:stopped)
+      expect(@provider).to receive(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-rs', '/system/myservice'], true)
+      expect(@provider).to receive(:wait).with('online')
       @provider.start
     end
 
     it "should always execute external command 'svcadm enable /system/myservice'" do
-      @provider.expects(:status).returns :running
-      @provider.expects(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-rs', '/system/myservice'], true)
-      @provider.expects(:wait).with('online')
+      expect(@provider).to receive(:status).and_return(:running)
+      expect(@provider).to receive(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-rs', '/system/myservice'], true)
+      expect(@provider).to receive(:wait).with('online')
       @provider.start
     end
 
     it "should execute external command 'svcadm clear /system/myservice' if in maintenance" do
-      @provider.stubs(:status).returns :maintenance
-      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
-      @provider.expects(:wait).with('online')
+      allow(@provider).to receive(:status).and_return(:maintenance)
+      expect(@provider).to receive(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
+      expect(@provider).to receive(:wait).with('online')
       @provider.start
     end
 
     it "should execute external command 'svcadm clear /system/myservice' if in degraded" do
-      @provider.stubs(:status).returns :degraded
-      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
-      @provider.expects(:wait).with('online')
+      allow(@provider).to receive(:status).and_return(:degraded)
+      expect(@provider).to receive(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
+      expect(@provider).to receive(:wait).with('online')
       @provider.start
     end
 
     it "should error if timeout occurs while starting the service" do
-      @provider.expects(:status).returns :stopped
-      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, '-rs', "/system/myservice"], true)
-      Timeout.expects(:timeout).with(60).raises(Timeout::Error)
+      expect(@provider).to receive(:status).and_return(:stopped)
+      expect(@provider).to receive(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, '-rs', "/system/myservice"], true)
+      expect(Timeout).to receive(:timeout).with(60).and_raise(Timeout::Error)
       expect { @provider.start }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
     end
   end
@@ -148,70 +156,70 @@ describe 'Puppet::Type::Service::Provider::Smf',
     before(:each) do
       @resource = Puppet::Type.type(:service).new(:name => "/system/myservice", :ensure => :running, :enable => :true, :manifest => "/tmp/myservice.xml")
       @provider = provider_class.new(@resource)
-      $CHILD_STATUS.stubs(:exitstatus).returns(1)
+      allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
     end
 
     it "should import the manifest if service is missing" do
-      @provider.stubs(:complete_service?).returns(true)
-      @provider.expects(:svcs).with('-l', '/system/myservice').raises(Puppet::ExecutionFailure, "Exited 1")
-      @provider.expects(:svccfg).with(:import, "/tmp/myservice.xml")
-      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, '-rs', "/system/myservice"], true)
-      @provider.expects(:wait).with('online')
-      @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
+      allow(@provider).to receive(:complete_service?).and_return(true)
+      expect(@provider).to receive(:svcs).with('-l', '/system/myservice').and_raise(Puppet::ExecutionFailure, "Exited 1")
+      expect(@provider).to receive(:svccfg).with(:import, "/tmp/myservice.xml")
+      expect(@provider).to receive(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, '-rs', "/system/myservice"], true)
+      expect(@provider).to receive(:wait).with('online')
+      expect(@provider).to receive(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").and_return("online\t-")
       @provider.start
     end
 
     it "should handle failures if importing a manifest" do
-      @provider.expects(:svcs).with('-l', '/system/myservice').raises(Puppet::ExecutionFailure, "Exited 1")
-      @provider.expects(:svccfg).raises(Puppet::ExecutionFailure.new("can't svccfg import"))
+      expect(@provider).to receive(:svcs).with('-l', '/system/myservice').and_raise(Puppet::ExecutionFailure, "Exited 1")
+      expect(@provider).to receive(:svccfg).and_raise(Puppet::ExecutionFailure.new("can't svccfg import"))
       expect { @provider.start }.to raise_error(Puppet::Error, "Cannot config /system/myservice to enable it: can't svccfg import")
     end
   end
 
   context "when stopping" do
     it "should execute external command 'svcadm disable /system/myservice'" do
-      @provider.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, '-s', "/system/myservice"], true)
-      @provider.expects(:wait).with('offline', 'disabled', 'uninitialized')
+      expect(@provider).to receive(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, '-s', "/system/myservice"], true)
+      expect(@provider).to receive(:wait).with('offline', 'disabled', 'uninitialized')
       @provider.stop
     end
 
     it "should error if timeout occurs while stopping the service" do
-      @provider.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, '-s', "/system/myservice"], true)
-      Timeout.expects(:timeout).with(60).raises(Timeout::Error)
+      expect(@provider).to receive(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, '-s', "/system/myservice"], true)
+      expect(Timeout).to receive(:timeout).with(60).and_raise(Timeout::Error)
       expect { @provider.stop }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
     end
   end
 
   context "when restarting" do
     it "should error if timeout occurs while restarting the service" do
-      @provider.expects(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, '-s', "/system/myservice"], true)
-      Timeout.expects(:timeout).with(60).raises(Timeout::Error)
+      expect(@provider).to receive(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, '-s', "/system/myservice"], true)
+      expect(Timeout).to receive(:timeout).with(60).and_raise(Timeout::Error)
       expect { @provider.restart }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
     end
 
     context 'with :operatingsystemrelease == 10_u10' do
       it "should call 'svcadm restart /system/myservice'" do
-        Facter.stubs(:value).with(:operatingsystemrelease).returns '10_u10'
-        @provider.expects(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, "/system/myservice"], true)
-        @provider.expects(:wait).with('online')
+        allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('10_u10')
+        expect(@provider).to receive(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, "/system/myservice"], true)
+        expect(@provider).to receive(:wait).with('online')
         @provider.restart
       end
     end
 
     context 'with :operatingsystemrelease == 11.2' do
       it "should call 'svcadm restart -s /system/myservice'" do
-        Facter.stubs(:value).with(:operatingsystemrelease).returns '11.2'
-        @provider.expects(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, '-s', "/system/myservice"], true)
-        @provider.expects(:wait).with('online')
+        allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.2')
+        expect(@provider).to receive(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, '-s', "/system/myservice"], true)
+        expect(@provider).to receive(:wait).with('online')
         @provider.restart
       end
     end
 
     context 'with :operatingsystemrelease > 11.2' do
       it "should call 'svcadm restart -s /system/myservice'" do
-        Facter.stubs(:value).with(:operatingsystemrelease).returns '11.3'
-        @provider.expects(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, '-s', "/system/myservice"], true)
-        @provider.expects(:wait).with('online')
+        allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.3')
+        expect(@provider).to receive(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, '-s', "/system/myservice"], true)
+        expect(@provider).to receive(:wait).with('online')
         @provider.restart
       end
     end
@@ -219,7 +227,7 @@ describe 'Puppet::Type::Service::Provider::Smf',
 
   describe '#service_fmri' do
     it 'raises a Puppet::Error if the service resource matches multiple FMRIs' do
-      @provider.stubs(:svcs).with('-l', @provider.resource[:name]).returns(File.read(my_fixture('svcs_multiple_fmris.out')))
+      allow(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_return(File.read(my_fixture('svcs_multiple_fmris.out')))
 
       expect { @provider.service_fmri }.to raise_error do |error|
         expect(error).to be_a(Puppet::Error)
@@ -232,7 +240,7 @@ describe 'Puppet::Type::Service::Provider::Smf',
     end
 
     it 'raises a Puppet:ExecutionFailure if svcs fails' do
-      @provider.stubs(:svcs).with('-l', @provider.resource[:name]).raises(
+      allow(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_raise(
         Puppet::ExecutionFailure, 'svcs failed!'
       )
 
@@ -243,7 +251,7 @@ describe 'Puppet::Type::Service::Provider::Smf',
     end
 
     it "returns the service resource's fmri and memoizes it" do
-      @provider.stubs(:svcs).with('-l', @provider.resource[:name]).returns(File.read(my_fixture('svcs_fmri.out')))
+      allow(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_return(File.read(my_fixture('svcs_fmri.out')))
 
       expected_fmri = 'svc:/application/tstapp:default'
 
@@ -256,24 +264,24 @@ describe 'Puppet::Type::Service::Provider::Smf',
     let(:fmri) { 'service_fmri' }
 
     before(:each) do
-      @provider.stubs(:service_fmri).returns(fmri)
+      allow(@provider).to receive(:service_fmri).and_return(fmri)
     end
 
     it 'should raise a Puppet::Error if it is called on an older Solaris machine' do
-      Facter.stubs(:value).with(:operatingsystemrelease).returns('10.0')
+      allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('10.0')
 
       expect { @provider.complete_service? }.to raise_error(Puppet::Error)
     end
 
     it 'should return false for an incomplete service' do
-      @provider.stubs(:svccfg).with('-s', fmri, 'listprop', 'general/complete').returns("")
+      allow(@provider).to receive(:svccfg).with('-s', fmri, 'listprop', 'general/complete').and_return("")
       expect(@provider.complete_service?).to be false
     end
 
     it 'should return true for a complete service' do
-      @provider.stubs(:svccfg)
+      allow(@provider).to receive(:svccfg)
         .with('-s', fmri, 'listprop', 'general/complete')
-        .returns("general/complete astring")
+        .and_return("general/complete astring")
 
       expect(@provider.complete_service?).to be true
     end

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

@@ -11,30 +11,30 @@ describe 'Puppet::Type::Service::Provider::Src',
   end
 
   before :each do
-    @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 = provider_class.new
     @provider.resource = @resource
 
-    @provider.stubs(:command).with(:stopsrc).returns "/usr/bin/stopsrc"
-    @provider.stubs(:command).with(:startsrc).returns "/usr/bin/startsrc"
-    @provider.stubs(:command).with(:lssrc).returns "/usr/bin/lssrc"
-    @provider.stubs(:command).with(:refresh).returns "/usr/bin/refresh"
-    @provider.stubs(:command).with(:lsitab).returns "/usr/sbin/lsitab"
-    @provider.stubs(:command).with(:mkitab).returns "/usr/sbin/mkitab"
-    @provider.stubs(:command).with(:rmitab).returns "/usr/sbin/rmitab"
-    @provider.stubs(:command).with(:chitab).returns "/usr/sbin/chitab"
-
-    @provider.stubs(:stopsrc)
-    @provider.stubs(:startsrc)
-    @provider.stubs(:lssrc)
-    @provider.stubs(:refresh)
-    @provider.stubs(:lsitab)
-    @provider.stubs(:mkitab)
-    @provider.stubs(:rmitab)
-    @provider.stubs(:chitab)
+    allow(@provider).to receive(:command).with(:stopsrc).and_return("/usr/bin/stopsrc")
+    allow(@provider).to receive(:command).with(:startsrc).and_return("/usr/bin/startsrc")
+    allow(@provider).to receive(:command).with(:lssrc).and_return("/usr/bin/lssrc")
+    allow(@provider).to receive(:command).with(:refresh).and_return("/usr/bin/refresh")
+    allow(@provider).to receive(:command).with(:lsitab).and_return("/usr/sbin/lsitab")
+    allow(@provider).to receive(:command).with(:mkitab).and_return("/usr/sbin/mkitab")
+    allow(@provider).to receive(:command).with(:rmitab).and_return("/usr/sbin/rmitab")
+    allow(@provider).to receive(:command).with(:chitab).and_return("/usr/sbin/chitab")
+
+    allow(@provider).to receive(:stopsrc)
+    allow(@provider).to receive(:startsrc)
+    allow(@provider).to receive(:lssrc)
+    allow(@provider).to receive(:refresh)
+    allow(@provider).to receive(:lsitab)
+    allow(@provider).to receive(:mkitab)
+    allow(@provider).to receive(:rmitab)
+    allow(@provider).to receive(:chitab)
   end
 
   context ".instances" do
@@ -50,7 +50,7 @@ myservice.2:::/usr/sbin/inetd:0:0:/dev/console:/dev/console:/dev/console:-O:-Q:-
 myservice.3:::/usr/sbin/inetd:0:0:/dev/console:/dev/console:/dev/console:-O:-Q:-K:0:0:20:0:0:-d:20:tcpip:
 myservice.4:::/usr/sbin/inetd:0:0:/dev/console:/dev/console:/dev/console:-O:-Q:-K:0:0:20:0:0:-d:20:tcpip:
 _EOF_
-      provider_class.stubs(:lssrc).returns sample_output
+      allow(provider_class).to receive(:lssrc).and_return(sample_output)
       expect(provider_class.instances.map(&:name)).to eq([
         'myservice.1',
         'myservice.2',
@@ -58,33 +58,32 @@ _EOF_
         'myservice.4'
       ])
     end
-
   end
 
   context "when starting a service" do
     it "should execute the startsrc command" do
-      @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
-      @provider.expects(:status).returns :running
+      expect(@provider).to receive(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      expect(@provider).to receive(:status).and_return(:running)
       @provider.start
     end
 
     it "should error if timeout occurs while stopping the service" do
-      @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
-      Timeout.expects(:timeout).with(60).raises(Timeout::Error)
+      expect(@provider).to receive(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      expect(Timeout).to receive(:timeout).with(60).and_raise(Timeout::Error)
       expect { @provider.start }.to raise_error Puppet::Error, ('Timed out waiting for myservice to transition states')
     end
   end
 
   context "when stopping a service" do
     it "should execute the stopsrc command" do
-      @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
-      @provider.expects(:status).returns :stopped
+      expect(@provider).to receive(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      expect(@provider).to receive(:status).and_return(:stopped)
       @provider.stop
     end
 
     it "should error if timeout occurs while stopping the service" do
-      @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
-      Timeout.expects(:timeout).with(60).raises(Timeout::Error)
+      expect(@provider).to receive(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      expect(Timeout).to receive(:timeout).with(60).and_raise(Timeout::Error)
       expect { @provider.stop }.to raise_error Puppet::Error, ('Timed out waiting for myservice to transition states')
     end
   end
@@ -99,34 +98,34 @@ _EOF_
 
   context "when enabling" do
     it "should execute the mkitab command" do
-      @provider.expects(:mkitab).with("myservice:2:once:/usr/bin/startsrc -s myservice").once
+      expect(@provider).to receive(:mkitab).with("myservice:2:once:/usr/bin/startsrc -s myservice").once
       @provider.enable
     end
   end
 
   context "when disabling" do
     it "should execute the rmitab command" do
-      @provider.expects(:rmitab).with("myservice")
+      expect(@provider).to receive(:rmitab).with("myservice")
       @provider.disable
     end
   end
 
   context "when checking if it is enabled" do
     it "should execute the lsitab command" do
-      @provider.expects(:execute).with(['/usr/sbin/lsitab', 'myservice'], {:combine => true, :failonfail => false})
-      $CHILD_STATUS.stubs(:exitstatus).returns(0)
+      expect(@provider).to receive(:execute).with(['/usr/sbin/lsitab', 'myservice'], {:combine => true, :failonfail => false})
+      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
       @provider.enabled?
     end
 
     it "should return false when lsitab returns non-zero" do
-      @provider.stubs(:execute)
-      $CHILD_STATUS.stubs(:exitstatus).returns(1)
+      allow(@provider).to receive(:execute)
+      allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
       expect(@provider.enabled?).to eq(:false)
     end
 
     it "should return true when lsitab returns zero" do
-      @provider.stubs(:execute)
-      $CHILD_STATUS.stubs(:exitstatus).returns(0)
+      allow(@provider).to receive(:execute)
+      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
       expect(@provider.enabled?).to eq(:true)
     end
   end
@@ -138,7 +137,7 @@ _EOF_
   myservice         tcpip            1234         active
 _EOF_
 
-      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
+      expect(@provider).to receive(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).and_return(sample_output)
       expect(@provider.status).to eq(:running)
     end
 
@@ -148,7 +147,7 @@ _EOF_
   myservice         tcpip                         inoperative
 _EOF_
 
-      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
+      expect(@provider).to receive(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).and_return(sample_output)
       expect(@provider.status).to eq(:stopped)
     end
 
@@ -158,12 +157,12 @@ _EOF_
   myservice         tcpip                         randomdata
 _EOF_
 
-      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
+      expect(@provider).to receive(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).and_return(sample_output)
       expect(@provider.status).to eq(nil)
     end
 
     it "should consider a non-existing service to be have a status of :stopped" do
-      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', 'myservice']).raises(Puppet::ExecutionFailure, "fail")
+      expect(@provider).to receive(:execute).with(['/usr/bin/lssrc', '-s', 'myservice']).and_raise(Puppet::ExecutionFailure, "fail")
       expect(@provider.status).to eq(:stopped)
     end
   end
@@ -174,8 +173,8 @@ _EOF_
 #subsysname:synonym:cmdargs:path:uid:auditid:standin:standout:standerr:action:multi:contact:svrkey:svrmtype:priority:signorm:sigforce:display:waittime:grpname:
 myservice:::/usr/sbin/inetd:0:0:/dev/console:/dev/console:/dev/console:-O:-Q:-K:0:0:20:0:0:-d:20:tcpip:
 _EOF_
-      @provider.expects(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).returns sample_output
-      @provider.expects(:execute).with(['/usr/bin/refresh', '-s', "myservice"])
+      expect(@provider).to receive(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).and_return(sample_output)
+      expect(@provider).to receive(:execute).with(['/usr/bin/refresh', '-s', "myservice"])
       @provider.restart
     end
 
@@ -185,9 +184,9 @@ _EOF_
 myservice::--no-daemonize:/usr/sbin/puppetd:0:0:/dev/null:/var/log/puppet.log:/var/log/puppet.log:-O:-Q:-S:0:0:20:15:9:-d:20::"
 _EOF_
 
-      @provider.expects(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).returns sample_output
-      @provider.expects(:stop)
-      @provider.expects(:start)
+      expect(@provider).to receive(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).and_return(sample_output)
+      expect(@provider).to receive(:stop)
+      expect(@provider).to receive(:start)
       @provider.restart
     end
   end