puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

@@ -1,29 +1,38 @@
+#! /usr/bin/env ruby
+#
+# Unit testing for the SMF service Provider
+#
+# author Dominic Cleal
+#
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:smf), :if => Puppet.features.posix? do
+describe 'Puppet::Type::Service::Provider::Smf',
+    if: Puppet.features.posix? && !Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:smf) }
+
   before(:each) do
     # Create a mock resource
     @resource = Puppet::Type.type(:service).new(
       :name => "/system/myservice", :ensure => :running, :enable => :true)
-    @provider = described_class.new(@resource)
+    @provider = provider_class.new(@resource)
 
-    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')
+    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'
   end
 
-  context ".instances" do
+  describe ".instances" do
     it "should have an instances method" do
-      expect(described_class).to respond_to :instances
+      expect(provider_class).to respond_to :instances
     end
 
     it "should get a list of services (excluding legacy)" do
-      expect(described_class).to receive(:svcs).with('-H', '-o', 'state,fmri').and_return(File.read(my_fixture('svcs.out')))
-      instances = described_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
+      provider_class.expects(:svcs).with('-H', '-o', 'state,fmri').returns 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)
       expect(instances[0]).to eq({:name => 'svc:/system/svc/restarter:default', :ensure => :running })
@@ -61,226 +70,148 @@ describe Puppet::Type.type(:service).provider(:smf), :if => Puppet.features.posi
   end
 
   describe "when checking status" do
-    before(:each) do
-      allow(@provider).to receive(:complete_service?).and_return(true)
-    end
-
     it "should call the external command 'svcs /system/myservice' once" do
-      expect(@provider).to receive(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").and_return("online\t-")
+      @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
       @provider.status
     end
-
     it "should return stopped if svcs can't find the service" do
-      allow(@provider).to receive(:svcs).and_raise(Puppet::ExecutionFailure.new("no svc found"))
+      @provider.stubs(:svcs).raises(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
-      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
-      allow(@provider).to receive(:svcs).and_return("online\t-")
+      @provider.stubs(:svcs).returns("online\t-")
       expect(@provider.status).to eq(:running)
     end
-
     it "should return stopped if disabled in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("disabled\t-")
+      @provider.stubs(:svcs).returns("disabled\t-")
       expect(@provider.status).to eq(:stopped)
     end
-
     it "should return maintenance if in maintenance in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("maintenance\t-")
+      @provider.stubs(:svcs).returns("maintenance\t-")
       expect(@provider.status).to eq(:maintenance)
     end
-
     it "should return degraded if in degraded in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("degraded\t-")
+      @provider.stubs(:svcs).returns("degraded\t-")
       expect(@provider.status).to eq(:degraded)
     end
-
     it "should return target state if transitioning in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("online\tdisabled")
+      @provider.stubs(:svcs).returns("online\tdisabled")
       expect(@provider.status).to eq(:stopped)
     end
-
     it "should throw error if it's a legacy service in svcs output" do
-      allow(@provider).to receive(:svcs).and_return("legacy_run\t-")
+      @provider.stubs(:svcs).returns("legacy_run\t-")
       expect { @provider.status }.to raise_error(Puppet::Error, "Cannot manage legacy services through SMF")
     end
   end
 
-  context "when starting" do
+  describe "when starting" do
     it "should enable the service if it is not enabled" do
-      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.expects(:status).returns :stopped
+      @provider.expects(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-rs', '/system/myservice'], true)
+      @provider.expects(:wait).with('online')
       @provider.start
     end
 
     it "should always execute external command 'svcadm enable /system/myservice'" do
-      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.expects(:status).returns :running
+      @provider.expects(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-rs', '/system/myservice'], true)
+      @provider.expects(:wait).with('online')
       @provider.start
     end
 
     it "should execute external command 'svcadm clear /system/myservice' if in maintenance" do
-      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.stubs(:status).returns :maintenance
+      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
+      @provider.expects(:wait).with('online')
       @provider.start
     end
 
     it "should execute external command 'svcadm clear /system/myservice' if in degraded" do
-      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.stubs(:status).returns :degraded
+      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
+      @provider.expects(:wait).with('online')
       @provider.start
     end
 
     it "should error if timeout occurs while starting the service" do
-      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)
+      @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.start }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
     end
   end
 
-  context "when starting a service with a manifest" do
+  describe "when starting a service with a manifest" do
     before(:each) do
       @resource = Puppet::Type.type(:service).new(:name => "/system/myservice", :ensure => :running, :enable => :true, :manifest => "/tmp/myservice.xml")
-      @provider = described_class.new(@resource)
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+      @provider = provider_class.new(@resource)
+      $CHILD_STATUS.stubs(:exitstatus).returns(1)
     end
 
     it "should import the manifest if service is missing" do
-      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.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-")
       @provider.start
     end
 
     it "should handle failures if importing a manifest" do
-      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"))
+      @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.start }.to raise_error(Puppet::Error, "Cannot config /system/myservice to enable it: can't svccfg import")
     end
   end
 
-  context "when stopping" do
+  describe "when stopping" do
     it "should execute external command 'svcadm disable /system/myservice'" do
-      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.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, '-s', "/system/myservice"], true)
+      @provider.expects(:wait).with('offline', 'disabled', 'uninitialized')
       @provider.stop
     end
 
     it "should error if timeout occurs while stopping the service" do
-      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)
+      @provider.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, '-s', "/system/myservice"], true)
+      Timeout.expects(:timeout).with(60).raises(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
+  describe "when restarting" do
+
     it "should error if timeout occurs while restarting the service" do
-      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)
+      @provider.expects(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, '-s', "/system/myservice"], true)
+      Timeout.expects(:timeout).with(60).raises(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
-        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')
+        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')
         @provider.restart
       end
     end
 
     context 'with :operatingsystemrelease == 11.2' do
       it "should call 'svcadm restart -s /system/myservice'" do
-        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')
+        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')
         @provider.restart
       end
     end
 
     context 'with :operatingsystemrelease > 11.2' do
       it "should call 'svcadm restart -s /system/myservice'" do
-        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')
+        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')
         @provider.restart
       end
     end
-  end
-
-  describe '#service_fmri' do
-    it 'raises a Puppet::Error if the service resource matches multiple FMRIs' do
-      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)
-        expect(error.message).to match(@provider.resource[:name])
-        expect(error.message).to match('multiple')
-
-        matched_fmris = ["svc:/application/tstapp:one", "svc:/application/tstapp:two"]
-        expect(error.message).to match(matched_fmris.join(', '))
-      end
-    end
 
-    it 'raises a Puppet:ExecutionFailure if svcs fails' do
-      allow(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_raise(
-        Puppet::ExecutionFailure, 'svcs failed!'
-      )
-
-      expect { @provider.service_fmri }.to raise_error do |error|
-        expect(error).to be_a(Puppet::ExecutionFailure)
-        expect(error.message).to match('svcs failed!')
-      end
-    end
-
-    it "returns the service resource's fmri and memoizes it" do
-      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'
-
-      expect(@provider.service_fmri).to eql(expected_fmri)
-      expect(@provider.instance_variable_get(:@fmri)).to eql(expected_fmri)
-    end
-  end
-
-  describe '#complete_service?' do
-    let(:fmri) { 'service_fmri' }
-
-    before(:each) do
-      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
-      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
-      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
-      allow(@provider).to receive(:svccfg)
-        .with('-s', fmri, 'listprop', 'general/complete')
-        .and_return("general/complete astring")
-
-      expect(@provider.complete_service?).to be true
-    end
   end
 end

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

@@ -1,42 +1,49 @@
+#! /usr/bin/env ruby
+#
+# Unit testing for the AIX System Resource Controller (src) provider
+#
+
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:src) do
-  if Puppet.features.microsoft_windows?
+describe 'Puppet::Type::Service::Provider::Src', unless: Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:src) }
+
+  if Puppet::Util::Platform.windows?
     # Get a pid for $CHILD_STATUS to latch on to
     command = "cmd.exe /c \"exit 0\""
     Puppet::Util::Execution.execute(command, {:failonfail => false})
   end
 
   before :each do
-    @resource = double('resource')
-    allow(@resource).to receive(:[]).and_return(nil)
-    allow(@resource).to receive(:[]).with(:name).and_return("myservice")
+    @resource = stub 'resource'
+    @resource.stubs(:[]).returns(nil)
+    @resource.stubs(:[]).with(:name).returns "myservice"
 
-    @provider = subject()
+    @provider = provider_class.new
     @provider.resource = @resource
 
-    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)
+    @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)
   end
 
-  context ".instances" do
+  describe ".instances" do
     it "should have a .instances method" do
-      expect(described_class).to respond_to :instances
+      expect(provider_class).to respond_to :instances
     end
 
     it "should get a list of running services" do
@@ -47,45 +54,46 @@ 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_
-      allow(described_class).to receive(:lssrc).and_return(sample_output)
-      expect(described_class.instances.map(&:name)).to eq([
+      provider_class.stubs(:lssrc).returns sample_output
+      expect(provider_class.instances.map(&:name)).to eq([
         'myservice.1',
         'myservice.2',
         'myservice.3',
         'myservice.4'
       ])
     end
+
   end
 
-  context "when starting a service" do
+  describe "when starting a service" do
     it "should execute the startsrc command" do
-      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.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      @provider.expects(:status).returns :running
       @provider.start
     end
 
     it "should error if timeout occurs while stopping the service" do
-      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)
+      @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.start }.to raise_error Puppet::Error, ('Timed out waiting for myservice to transition states')
     end
   end
 
-  context "when stopping a service" do
+  describe "when stopping a service" do
     it "should execute the stopsrc command" do
-      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.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      @provider.expects(:status).returns :stopped
       @provider.stop
     end
 
     it "should error if timeout occurs while stopping the service" do
-      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)
+      @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.stop }.to raise_error Puppet::Error, ('Timed out waiting for myservice to transition states')
     end
   end
 
-  context "should have a set of methods" do
+  describe "should have a set of methods" do
     [:enabled?, :enable, :disable, :start, :stop, :status, :restart].each do |method|
       it "should have a #{method} method" do
         expect(@provider).to respond_to(method)
@@ -93,48 +101,49 @@ _EOF_
     end
   end
 
-  context "when enabling" do
+  describe "when enabling" do
     it "should execute the mkitab command" do
-      expect(@provider).to receive(:mkitab).with("myservice:2:once:/usr/bin/startsrc -s myservice").once
+      @provider.expects(:mkitab).with("myservice:2:once:/usr/bin/startsrc -s myservice").once
       @provider.enable
     end
   end
 
-  context "when disabling" do
+  describe "when disabling" do
     it "should execute the rmitab command" do
-      expect(@provider).to receive(:rmitab).with("myservice")
+      @provider.expects(:rmitab).with("myservice")
       @provider.disable
     end
   end
 
-  context "when checking if it is enabled" do
+  describe "when checking if it is enabled" do
     it "should execute the lsitab command" do
-      expect(@provider).to receive(:execute).with(['/usr/sbin/lsitab', 'myservice'], {:combine => true, :failonfail => false})
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+      @provider.expects(:execute).with(['/usr/sbin/lsitab', 'myservice'], {:combine => true, :failonfail => false})
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       @provider.enabled?
     end
 
     it "should return false when lsitab returns non-zero" do
-      allow(@provider).to receive(:execute)
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+      @provider.stubs(:execute)
+      $CHILD_STATUS.stubs(:exitstatus).returns(1)
       expect(@provider.enabled?).to eq(:false)
     end
 
     it "should return true when lsitab returns zero" do
-      allow(@provider).to receive(:execute)
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+      @provider.stubs(:execute)
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       expect(@provider.enabled?).to eq(:true)
     end
   end
 
-  context "when checking a subsystem's status" do
+
+  describe "when checking a subsystem's status" do
     it "should execute status and return running if the subsystem is active" do
       sample_output = <<_EOF_
   Subsystem         Group            PID          Status
   myservice         tcpip            1234         active
 _EOF_
 
-      expect(@provider).to receive(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).and_return(sample_output)
+      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
       expect(@provider.status).to eq(:running)
     end
 
@@ -144,7 +153,7 @@ _EOF_
   myservice         tcpip                         inoperative
 _EOF_
 
-      expect(@provider).to receive(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).and_return(sample_output)
+      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
       expect(@provider.status).to eq(:stopped)
     end
 
@@ -154,24 +163,24 @@ _EOF_
   myservice         tcpip                         randomdata
 _EOF_
 
-      expect(@provider).to receive(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).and_return(sample_output)
+      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
       expect(@provider.status).to eq(nil)
     end
 
     it "should consider a non-existing service to be have a status of :stopped" do
-      expect(@provider).to receive(:execute).with(['/usr/bin/lssrc', '-s', 'myservice']).and_raise(Puppet::ExecutionFailure, "fail")
+      @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', 'myservice']).raises(Puppet::ExecutionFailure, "fail")
       expect(@provider.status).to eq(:stopped)
     end
   end
 
-  context "when restarting a service" do
+  describe "when restarting a service" do
     it "should execute restart which runs refresh" do
       sample_output = <<_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_
-      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.expects(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).returns sample_output
+      @provider.expects(:execute).with(['/usr/bin/refresh', '-s', "myservice"])
       @provider.restart
     end
 
@@ -181,9 +190,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_
 
-      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.expects(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).returns sample_output
+      @provider.expects(:stop)
+      @provider.expects(:start)
       @provider.restart
     end
   end