puppet 4.2.0 → 4.3.0

data/spec/unit/provider/package/yum_spec.rb

@@ -22,7 +22,7 @@ describe provider_class do
   end
 
   before do
-    provider.stubs(:yum).returns 'yum'
+    provider_class.stubs(:command).with(:cmd).returns('/usr/bin/yum')
     provider.stubs(:rpm).returns 'rpm'
     provider.stubs(:get).with(:version).returns '1'
     provider.stubs(:get).with(:release).returns '1'
@@ -181,14 +181,29 @@ describe provider_class do
       Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
       provider.stubs(:which).with("rpm").returns("/bin/rpm")
       Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns("4.10.1\n").at_most_once
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns('6')
     end
 
     it 'should call yum install for :installed' do
       resource.stubs(:should).with(:ensure).returns :installed
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, name)
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, 'mypackage'])
       provider.install
     end
 
+    context 'on el-5' do
+      before(:each) do
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('5')
+      end
+
+      it 'should catch yum install failures when status code is wrong' do
+        resource.stubs(:should).with(:ensure).returns :installed
+        Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-e', '0', '-y', :install, name]).returns("No package #{name} available.")
+        expect {
+          provider.install
+        }.to raise_error(Puppet::Error, "Could not find package #{name}")
+      end
+    end
+
     it 'should use :install to update' do
       provider.expects(:install)
       provider.update
@@ -197,7 +212,7 @@ describe provider_class do
     it 'should be able to set version' do
       version = '1.2'
       resource[:ensure] = version
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, "#{name}-#{version}")
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, "#{name}-#{version}"])
       provider.stubs(:query).returns :ensure => version
       provider.install
     end
@@ -205,6 +220,7 @@ describe provider_class do
     it 'should handle partial versions specified' do
       version = '1.3.4'
       resource[:ensure] = version
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, 'mypackage-1.3.4'])
       provider.stubs(:query).returns :ensure => '1.3.4-1.el6'
       provider.install
     end
@@ -213,7 +229,7 @@ describe provider_class do
       current_version = '1.2'
       version = '1.0'
       resource[:ensure] = '1.0'
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :downgrade, "#{name}-#{version}")
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :downgrade, "#{name}-#{version}"])
       provider.stubs(:query).returns(:ensure => current_version).then.returns(:ensure => version)
       provider.install
     end
@@ -222,22 +238,22 @@ describe provider_class do
       resource[:ensure] = :installed
       resource[:install_options] = ['-t', {'-x' => 'expackage'}]
 
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', ['-t', '-x=expackage'], :install, name)
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', ['-t', '-x=expackage'], :install, name])
       provider.install
     end
 
     it 'allow virtual packages' do
       resource[:ensure] = :installed
       resource[:allow_virtual] = true
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :list, name).never
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, name)
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :list, name]).never
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, name])
       provider.install
     end
   end
 
   describe 'when uninstalling' do
     it 'should use erase to purge' do
-      provider.expects(:yum).with('-y', :erase, name)
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-y', :erase, name])
       provider.purge
     end
   end
@@ -382,10 +398,6 @@ describe provider_class do
   end
 
   describe "executing yum check-update" do
-    before do
-      described_class.stubs(:command).with(:yum).returns '/usr/bin/yum'
-    end
-
     it "passes repos to enable to 'yum check-update'" do
       Puppet::Util::Execution.expects(:execute).with do |args, *rest|
         expect(args).to eq %w[/usr/bin/yum check-update --enablerepo=updates --enablerepo=centosplus]
@@ -482,6 +494,17 @@ describe provider_class do
         expect(output).not_to include("1:1.0.0-14.git20150121.b4ea599c.el7")
       end
     end
+    describe "with security notifications" do
+      let(:check_update) { File.read(my_fixture('yum-check-update-security.txt')) }
+      let(:output) { described_class.parse_updates(check_update) }
+
+      it "ignores all entries including and after 'Security'" do
+        expect(output).not_to include("Security")
+      end
+      it "includes updates before 'Security'" do
+        expect(output).to include("yum-plugin-fastestmirror.noarch")
+      end
+    end
   end
 
   describe "parsing a line from yum check-update" do

data/spec/unit/provider/scheduled_task/win32_taskscheduler_spec.rb

@@ -600,6 +600,16 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
       expect(resource.provider.exists?).to eq(true)
     end
+
+    it "uses SystemRoot in the path of Task folder" do
+      Win32::TaskScheduler.unstub(:new)
+      exists_test_task = Win32::TaskScheduler.new
+      Dir.stubs(:foreach).with('D:/WinNT/Tasks').returns([])
+
+      Puppet::Util.withenv('SystemRoot' => 'D:/WinNT') do
+        exists_test_task.exists?('Test Task')
+      end
+    end
   end
 
   describe '#clear_task' do

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

@@ -84,6 +84,7 @@ describe provider_class do
   describe "when checking whether it is enabled" do
     it "should call Kernel.system() with the appropriate parameters" do
       @provider.expects(:system).with("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start").once
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       @provider.enabled?
     end
 
@@ -140,4 +141,31 @@ describe provider_class do
     end
   end
 
+  describe "when checking service status" do
+    context "On systems which use the systemd-sysvinit compatibility layer" do
+      it "should call systemctl to determine running status in Debian" do
+        Facter.stubs(:value).with(:operatingsystem).returns('Debian')
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('8')
+        @resource.stubs(:[]).with(:hasstatus).returns(:true)
+        expect(@provider.statuscmd).to eq(["systemctl", "is-active", @resource[:name]])
+      end
+
+      it "should call systemctl to determine running status in Ubuntu" do
+        Facter.stubs(:value).with(:operatingsystem).returns('Ubuntu')
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('15.04')
+        @resource.stubs(:[]).with(:hasstatus).returns(:true)
+        expect(@provider.statuscmd).to eq(["systemctl", "is-active", @resource[:name]])
+      end
+    end
+
+    context "On systems which only use sysvinit" do
+      it "should use the service init script" do
+        Facter.stubs(:value).with(:operatingsystem).returns('Debian')
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('7')
+        @resource.stubs(:[]).with(:hasstatus).returns(:true)
+        @provider.stubs(:initscript).returns("/etc/init.d/script")
+        expect(@provider.statuscmd).to eq(["/etc/init.d/script", :status])
+      end
+    end
+  end
 end

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

@@ -159,6 +159,7 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
         provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
         provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.status
       end
 

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

@@ -147,10 +147,14 @@ describe Puppet::Type.type(:service).provider(:init) do
         expect(provider).to respond_to(method)
       end
       describe "when running #{method}" do
+        before :each do
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
+        end
 
         it "should use any provided explicit command" do
           resource[method] = "/user/specified/command"
           provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
+
           provider.send(method)
         end
 
@@ -158,6 +162,7 @@ describe Puppet::Type.type(:service).provider(:init) do
           resource[:hasrestart] = :true
           resource[:hasstatus] = :true
           provider.expects(:execute).with { |command, *args| command ==  ["/service/path/myservice",method]}
+
           provider.send(method)
         end
       end
@@ -170,6 +175,7 @@ describe Puppet::Type.type(:service).provider(:init) do
         end
         it "should execute the command" do
           provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
           provider.status
         end
         it "should consider the process running if the command returns 0" do

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

@@ -6,8 +6,9 @@ require 'spec_helper'
 describe Puppet::Type.type(:service).provider(:launchd) do
   let (:joblabel) { "com.foo.food" }
   let (:provider) { subject.class }
-  let (:launchd_overrides) { '/var/db/launchd.db/com.apple.launchd/overrides.plist' }
   let(:resource) { Puppet::Type.type(:service).new(:name => joblabel, :provider => :launchd) }
+  let (:launchd_overrides_6_9) { '/var/db/launchd.db/com.apple.launchd/overrides.plist' }
+  let (:launchd_overrides_10_) { '/var/db/com.apple.xpc.launchd/disabled.plist' }
   subject { resource.provider }
 
   describe "the type interface" do
@@ -37,6 +38,56 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     end
   end
 
+  [[10, '10.6'], [13, '10.9']].each do |kernel, version|
+    describe "when checking whether the service is enabled on OS X #{version}" do
+      it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => false}})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        expect(subject.enabled?).to eq(:true)
+      end
+      it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => true}})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        expect(subject.enabled?).to eq(:false)
+      end
+      it "should return true if the job plist and the global overrides have no disabled keys" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {}])
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        expect(subject.enabled?).to eq(:true)
+      end
+    end
+  end
+
+  describe "when checking whether the service is enabled on OS X 10.10" do
+    it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({joblabel => false})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
+      expect(subject.enabled?).to eq(:true)
+    end
+    it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({joblabel => true})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
+      expect(subject.enabled?).to eq(:false)
+    end
+    it "should return true if the job plist and the global overrides have no disabled keys" do
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {}])
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
+      expect(subject.enabled?).to eq(:true)
+    end
+  end
+
   describe "when starting the service" do
     it "should call any explicit 'start' command" do
       resource[:start] = "/bin/false"
@@ -47,13 +98,13 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     it "should look for the relevant plist once" do
       subject.expects(:plist_from_label).returns([joblabel, {}]).once
       subject.expects(:enabled?).returns :true
-      subject.expects(:execute).with([:launchctl, :load, joblabel])
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel])
       subject.start
     end
     it "should execute 'launchctl load' once without writing to the plist if the job is enabled" do
       subject.expects(:plist_from_label).returns([joblabel, {}])
       subject.expects(:enabled?).returns :true
-      subject.expects(:execute).with([:launchctl, :load, joblabel]).once
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel]).once
       subject.start
     end
     it "should execute 'launchctl load' with writing to the plist once if the job is disabled" do
@@ -147,21 +198,45 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     end
   end
 
-  describe "when enabling the service" do
+  [[10, "10.6"], [13, "10.9"]].each do |kernel, version|
+    describe "when enabling the service on OS X #{version}" do
+      it "should write to the global launchd overrides file once" do
+        resource[:enable] = true
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
+        Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], {'Disabled' => false}), launchd_overrides_6_9).once
+        subject.enable
+      end
+    end
+
+    describe "when disabling the service on OS X #{version}" do
+      it "should write to the global launchd overrides file once" do
+        resource[:enable] = false
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
+        Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], {'Disabled' => true}), launchd_overrides_6_9).once
+        subject.disable
+      end
+    end
+  end
+
+  describe "when enabling the service on OS X 10.10" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = true
-      provider.expects(:read_plist).returns({})
-      Plist::Emit.expects(:save_plist).once
+      provider.expects(:get_os_version).returns(14).at_least_once
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
+      Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], false), launchd_overrides_10_).once
       subject.enable
     end
   end
 
-  describe "when disabling the service" do
+  describe "when disabling the service on OS X 10.10" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = false
-      provider.stubs(:read_plist).returns({})
-      Plist::Emit.expects(:save_plist).once
-      subject.enable
+      provider.expects(:get_os_version).returns(14).at_least_once
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
+      Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], true), launchd_overrides_10_).once
+      subject.disable
     end
   end
 

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

@@ -146,6 +146,7 @@ describe Puppet::Type.type(:service).provider(:openrc) do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
         provider.expects(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
         provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.status
       end
 

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

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+provider_class = Puppet::Type.type(:service).provider(:rcng)
+
+describe provider_class, :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')
+    @provider = provider_class.new
+    @provider.stubs(:initscript)
+  end
+
+  describe "#enable" do
+    it "should have an enable method" do
+      expect(@provider).to respond_to(:enable)
+    end
+
+    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")
+      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")
+      provider.enable
+    end
+  end
+end

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

@@ -23,7 +23,7 @@ describe provider_class, :if => Puppet.features.posix? do
     Facter.stubs(:value).with(:osfamily).returns 'RedHat'
   end
 
-  osfamily = [ 'RedHat', 'Suse' ]
+  osfamily = [ 'RedHat' ]
 
   osfamily.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
@@ -32,6 +32,13 @@ describe provider_class, :if => Puppet.features.posix? do
     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")
+    expect(described_class.default?).to be_truthy
+  end
+
   # test self.instances
   describe "when getting all service instances" do
     before :each do

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

@@ -28,7 +28,7 @@ describe provider_class, :if => Puppet.features.posix? do
     end
 
     it "should get a list of services (excluding legacy)" do
-      provider_class.expects(:svcs).with().returns File.read(my_fixture('svcs.out'))
+      provider_class.expects(:svcs).with('-H').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(2)
@@ -99,21 +99,31 @@ describe provider_class, :if => Puppet.features.posix? do
   describe "when starting" do
     it "should enable the service if it is not enabled" do
       @provider.expects(:status).returns :stopped
-      @provider.expects(:texecute)
+      @provider.expects(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-s', '/system/myservice'], true)
+      @provider.expects(:wait).with('online')
       @provider.start
     end
 
     it "should always execute external command 'svcadm enable /system/myservice'" do
-      @provider.stubs(:status).returns :running
-      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "-s", "/system/myservice"], true)
+      @provider.expects(:status).returns :running
+      @provider.expects(:texecute).with(:start, ['/usr/sbin/svcadm', :enable, '-s', '/system/myservice'], true)
+      @provider.expects(: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')
       @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, "-s", "/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
 
   describe "when starting a service with a manifest" do
@@ -126,6 +136,7 @@ describe provider_class, :if => Puppet.features.posix? do
     it "should import the manifest if service is missing" do
       @provider.expects(:svccfg).with(:import, "/tmp/myservice.xml")
       @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "-s", "/system/myservice"], true)
+      @provider.expects(:wait).with('online')
       @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
       @provider.start
     end
@@ -139,15 +150,29 @@ describe provider_class, :if => Puppet.features.posix? do
   describe "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')
       @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.stop }.to raise_error Puppet::Error, ('Timed out waiting for /system/myservice to transition states')
+    end
   end
 
   describe "when restarting" do
     it "should call 'svcadm restart /system/myservice'" do
       @provider.expects(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, "/system/myservice"], true)
+      @provider.expects(:wait).with('online')
       @provider.restart
     end
-  end
 
+    it "should error if timeout occurs while restarting the service" do
+      @provider.expects(:texecute).with(:restart, ["/usr/sbin/svcadm", :restart, "/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
+
+  end
 end

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

@@ -37,7 +37,7 @@ describe provider_class do
   end
 
   describe ".instances" do
-    it "should has a .instances method" do
+    it "should have a .instances method" do
       expect(provider_class).to respond_to :instances
     end
 
@@ -63,15 +63,29 @@ _EOF_
   describe "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
       @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.start }.to raise_error Puppet::Error, ('Timed out waiting for myservice to transition states')
+    end
   end
 
   describe "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
       @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.stop }.to raise_error Puppet::Error, ('Timed out waiting for myservice to transition states')
+    end
   end
 
   describe "should have a set of methods" do
@@ -99,6 +113,7 @@ _EOF_
   describe "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)
       @provider.enabled?
     end
 
@@ -159,14 +174,15 @@ _EOF_
       @provider.restart
     end
 
-    it "should execute restart which runs stopsrc then startsrc" do
+    it "should execute restart which runs stop then start" 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::--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(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
-      @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => false, :combine => true, :failonfail => true})
+      @provider.expects(:stop)
+      @provider.expects(:start)
       @provider.restart
     end
   end