puppet 6.0.10 → 6.1.0

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platform.jruby? do
@@ -22,41 +23,59 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
   end
 
   def lists_processes_as(output)
-    allow(Puppet::Util::Execution).to receive(:execpipe).with("/sbin/initctl list").and_yield(output)
-    allow(provider_class).to receive(:which).with("/sbin/initctl").and_return("/sbin/initctl")
+    Puppet::Util::Execution.stubs(:execpipe).with("/sbin/initctl list").yields(output)
+    provider_class.stubs(:which).with("/sbin/initctl").returns("/sbin/initctl")
   end
 
   it "should be the default provider on Ubuntu" do
-    expect(Facter).to receive(:value).with(:operatingsystem).and_return("Ubuntu")
-    expect(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("12.04")
+    Facter.expects(:value).with(:operatingsystem).returns("Ubuntu")
+    Facter.expects(:value).with(:operatingsystemmajrelease).returns("12.04")
     expect(provider_class.default?).to be_truthy
   end
 
   context "upstart daemon existence confine" do
-    let(:initctl_version) { ['/sbin/initctl', 'version', '--quiet'] }
+    # We have a separate method here because our search for the upstart daemon
+    # confine expects it to be the last confine declared in the upstart provider.
+    # If in the future we add other confines below it or change its order, these
+    # unit tests will fail. Placing knowledge of where this confine is located
+    # in one place makes updating it less painful in case we ever need to do this.
+    def assert_upstart_daemon_existence_confine_is(expected_value)
+      # Reload our provider to evaluate the :confine block
+      provider_class = Puppet::Type.type(:service).provider(:upstart)
+
+      upstart_daemon_existence_confine = provider_class.confine_collection.instance_variable_get(:@confines)[-1]
+      expect(upstart_daemon_existence_confine.valid?).to be(expected_value)
+    end
 
+    let(:initctl_version) { ['/sbin/initctl', 'version', '--quiet'] }
     before(:each) do
-      allow(Puppet::Util).to receive(:which).with('/sbin/initctl').and_return('/sbin/initctl')
+      # Stub out /sbin/initctl
+      Puppet::Util.stubs(:which).with('/sbin/initctl').returns('/sbin/initctl')
+
+      # Both of our tests are asserting the confine :true block that shells out to
+      # `initctl version --quiet`. Its expression is evaluated at provider load-time.
+      # Hence before each test, we want to reload the upstart provider so that the
+      # confine is re-evaluated.
+      Puppet::Type.type(:service).unprovide(:upstart)
     end
 
     it "should return true when the daemon is running" do
-      expect(Puppet::Util::Execution).to receive(:execute).with(initctl_version, instance_of(Hash))
-
-      expect(provider_class).to be_has_initctl
+      Puppet::Util::Execution.expects(:execute).with(initctl_version, instance_of(Hash))
+      assert_upstart_daemon_existence_confine_is(true)
     end
 
     it "should return false when the daemon is not running" do
-      expect(Puppet::Util::Execution).to receive(:execute)
+      Puppet::Util::Execution.expects(:execute)
         .with(initctl_version, instance_of(Hash))
-        .and_raise(Puppet::ExecutionFailure, "initctl failed!")
+        .raises(Puppet::ExecutionFailure, "initctl failed!")
 
-      expect(provider_class).to_not be_has_initctl
+      assert_upstart_daemon_existence_confine_is(false)
     end
   end
 
   describe "excluding services" do
     it "ignores tty and serial on Redhat systems" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
+      Facter.stubs(:value).with(:osfamily).returns('RedHat')
       expect(provider_class.excludes).to include 'serial'
       expect(provider_class.excludes).to include 'tty'
     end
@@ -77,7 +96,7 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
 
     it "should attach the job name for network interface security" do
       processes = "network-interface-security (network-interface/eth0)"
-      allow(provider_class).to receive(:execpipe).and_yield(processes)
+      provider_class.stubs(:execpipe).yields(processes)
       expect(provider_class.instances.first.name).to eq("network-interface-security JOB=network-interface/eth0")
     end
 
@@ -89,16 +108,16 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
       processes += "\ncryptdisks-udev stop/waiting"
       processes += "\nstatd-mounting stop/waiting"
       processes += "\ngssd-mounting stop/waiting"
-      allow(provider_class).to receive(:execpipe).and_yield(processes)
+      provider_class.stubs(:execpipe).yields(processes)
       expect(provider_class.instances).to be_empty
     end
   end
 
   describe "#search" do
     it "searches through paths to find a matching conf file" do
-      allow(File).to receive(:directory?).and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("/etc/init/foo-bar.conf").and_return(true)
+      File.stubs(:directory?).returns(true)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
+      Puppet::FileSystem.expects(:exist?).with("/etc/init/foo-bar.conf").returns(true)
       resource = Puppet::Type.type(:service).new(:name => "foo-bar", :provider => :upstart)
       provider = provider_class.new(resource)
 
@@ -106,9 +125,9 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
     end
 
     it "searches for just the name of a compound named service" do
-      allow(File).to receive(:directory?).and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("/etc/init/network-interface.conf").and_return(true)
+      File.stubs(:directory?).returns(true)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
+      Puppet::FileSystem.expects(:exist?).with("/etc/init/network-interface.conf").returns(true)
       resource = Puppet::Type.type(:service).new(:name => "network-interface INTERFACE=lo", :provider => :upstart)
       provider = provider_class.new(resource)
 
@@ -120,10 +139,10 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
     it "should use the default status command if none is specified" do
       resource = Puppet::Type.type(:service).new(:name => "foo", :provider => :upstart)
       provider = provider_class.new(resource)
-      allow(provider).to receive(:is_upstart?).and_return(true)
+      provider.stubs(:is_upstart?).returns(true)
 
-      expect(provider).to receive(:status_exec).with(["foo"]).and_return("foo start/running, process 1000")
-      allow_any_instance_of(Process::Status).to receive(:exitstatus).and_return(0)
+      provider.expects(:status_exec).with(["foo"]).returns("foo start/running, process 1000")
+      Process::Status.any_instance.stubs(:exitstatus).returns(0)
       expect(provider.status).to eq(:running)
     end
 
@@ -131,33 +150,33 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
       it "should use the provided status command" do
         resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
         provider = provider_class.new(resource)
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
 
-        expect(provider).not_to receive(:status_exec).with(['foo'])
-        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow_any_instance_of(Process::Status).to receive(:exitstatus).and_return(0)
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        Process::Status.any_instance.stubs(:exitstatus).returns(0)
         provider.status
       end
 
       it "should return :stopped when the provided status command return non-zero" do
         resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
         provider = provider_class.new(resource)
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
 
-        expect(provider).not_to receive(:status_exec).with(['foo'])
-        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 1
         expect(provider.status).to eq(:stopped)
       end
 
       it "should return :running when the provided status command return zero" do
         resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
         provider = provider_class.new(resource)
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
 
-        expect(provider).not_to receive(:status_exec).with(['foo'])
-        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
         expect(provider.status).to eq(:running)
       end
     end
@@ -166,20 +185,20 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
       it "should return :stopped if the pid can not be found" do
         resource = Puppet::Type.type(:service).new(:name => 'foo', :hasstatus => false, :provider => :upstart)
         provider = provider_class.new(resource)
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
 
-        expect(provider).not_to receive(:status_exec).with(['foo'])
-        expect(provider).to receive(:getpid).and_return(nil)
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:getpid).returns nil
         expect(provider.status).to eq(:stopped)
       end
 
       it "should return :running if the pid can be found" do
         resource = Puppet::Type.type(:service).new(:name => 'foo', :hasstatus => false, :provider => :upstart)
         provider = provider_class.new(resource)
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
 
-        expect(provider).not_to receive(:status_exec).with(['foo'])
-        expect(provider).to receive(:getpid).and_return(2706)
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:getpid).returns 2706
         expect(provider.status).to eq(:running)
       end
     end
@@ -188,33 +207,33 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
       it "should use the provided status command" do
         resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
         provider = provider_class.new(resource)
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
 
-        expect(provider).not_to receive(:status_exec).with(['foo'])
-        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow_any_instance_of(Process::Status).to receive(:exitstatus).and_return(0)
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        Process::Status.any_instance.stubs(:exitstatus).returns(0)
         provider.status
       end
 
       it "should return :stopped when the provided status command return non-zero" do
         resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
         provider = provider_class.new(resource)
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
 
-        expect(provider).not_to receive(:status_exec).with(['foo'])
-        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 1
         expect(provider.status).to eq(:stopped)
       end
 
       it "should return :running when the provided status command return zero" do
         resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
         provider = provider_class.new(resource)
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
 
-        expect(provider).not_to receive(:status_exec).with(['foo'])
-        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
         expect(provider.status).to eq(:running)
       end
     end
@@ -223,20 +242,20 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
       it "should return :stopped if the pid can not be found" do
         resource = Puppet::Type.type(:service).new(:name => 'foo', :hasstatus => false, :provider => :upstart)
         provider = provider_class.new(resource)
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
 
-        expect(provider).not_to receive(:status_exec).with(['foo'])
-        expect(provider).to receive(:getpid).and_return(nil)
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:getpid).returns nil
         expect(provider.status).to eq(:stopped)
       end
 
       it "should return :running if the pid can be found" do
         resource = Puppet::Type.type(:service).new(:name => 'foo', :hasstatus => false, :provider => :upstart)
         provider = provider_class.new(resource)
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
 
-        expect(provider).not_to receive(:status_exec).with(['foo'])
-        expect(provider).to receive(:getpid).and_return(2706)
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:getpid).returns 2706
         expect(provider.status).to eq(:running)
       end
     end
@@ -244,10 +263,10 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
     it "should properly handle services with 'start' in their name" do
       resource = Puppet::Type.type(:service).new(:name => "foostartbar", :provider => :upstart)
       provider = provider_class.new(resource)
-      allow(provider).to receive(:is_upstart?).and_return(true)
+      provider.stubs(:is_upstart?).returns(true)
 
-      expect(provider).to receive(:status_exec).with(["foostartbar"]).and_return("foostartbar stop/waiting")
-      allow_any_instance_of(Process::Status).to receive(:exitstatus).and_return(0)
+      provider.expects(:status_exec).with(["foostartbar"]).returns("foostartbar stop/waiting")
+      Process::Status.any_instance.stubs(:exitstatus).returns(0)
       expect(provider.status).to eq(:stopped)
     end
   end
@@ -263,15 +282,13 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
 
     describe "when upstart job" do
       before(:each) do
-        allow(provider).to receive(:is_upstart?).and_return(true)
+        provider.stubs(:is_upstart?).returns(true)
       end
-
       ["start", "stop"].each do |action|
         it "should return the #{action}cmd of its parent provider" do
           expect(provider.send("#{action}cmd".to_sym)).to eq([provider.command(action.to_sym), resource.name])
         end
       end
-
       it "should return nil for the statuscmd" do
         expect(provider.statuscmd).to be_nil
       end
@@ -350,9 +367,9 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
 
     describe "Upstart version < 0.6.7" do
       before(:each) do
-        allow(provider).to receive(:is_upstart?).and_return(true)
-        allow(provider).to receive(:upstart_version).and_return("0.6.5")
-        allow(provider).to receive(:search).and_return(init_script)
+        provider.stubs(:is_upstart?).returns(true)
+        provider.stubs(:upstart_version).returns("0.6.5")
+        provider.stubs(:search).returns(init_script)
       end
 
       [:enabled?,:enable,:disable].each do |enableable|
@@ -436,9 +453,9 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
 
     describe "Upstart version < 0.9.0" do
       before(:each) do
-        allow(provider).to receive(:is_upstart?).and_return(true)
-        allow(provider).to receive(:upstart_version).and_return("0.7.0")
-        allow(provider).to receive(:search).and_return(init_script)
+        provider.stubs(:is_upstart?).returns(true)
+        provider.stubs(:upstart_version).returns("0.7.0")
+        provider.stubs(:search).returns(init_script)
       end
 
       [:enabled?,:enable,:disable].each do |enableable|
@@ -554,10 +571,10 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
 
     describe "Upstart version > 0.9.0" do
       before(:each) do
-        allow(provider).to receive(:is_upstart?).and_return(true)
-        allow(provider).to receive(:upstart_version).and_return("0.9.5")
-        allow(provider).to receive(:search).and_return(init_script)
-        allow(provider).to receive(:overscript).and_return(over_script)
+        provider.stubs(:is_upstart?).returns(true)
+        provider.stubs(:upstart_version).returns("0.9.5")
+        provider.stubs(:search).returns(init_script)
+        provider.stubs(:overscript).returns(over_script)
       end
 
       [:enabled?,:enable,:disable].each do |enableable|
@@ -655,7 +672,6 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
             expect(provider.enabled?).to eq(:false)
           end
         end
-
         describe "with override file" do
           it "should consider 'start on ...' to be disabled if there is manual in override file" do
             given_contents_of(init_script, enabled_content)

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

@@ -1,4 +1,10 @@
+#! /usr/bin/env ruby
+#
+# Unit testing for the Windows service Provider
+#
+
 require 'spec_helper'
+
 require 'win32/service' if Puppet::Util::Platform.windows?
 
 describe 'Puppet::Type::Service::Provider::Windows',
@@ -10,20 +16,20 @@ describe 'Puppet::Type::Service::Provider::Windows',
   let(:config)   { Struct::ServiceConfigInfo.new }
   let(:status)   { Struct::ServiceStatus.new }
   let(:service_util) { Puppet::Util::Windows::Service }
-  let(:service_handle) { double() }
+  let(:service_handle) { mock() }
 
   before :each do
     # make sure we never actually execute anything (there are two execute methods)
-    allow(provider.class).to receive(:execute)
-    allow(provider).to receive(:execute)
+    provider.class.expects(:execute).never
+    provider.expects(:execute).never
 
-    allow(service_util).to receive(:exists?).with(resource[:name]).and_return(true)
+    service_util.stubs(:exists?).with(resource[:name]).returns(true)
   end
 
   describe ".instances" do
     it "should enumerate all services" do
       list_of_services = {'snmptrap' => {}, 'svchost' => {}, 'sshd' => {}}
-      expect(service_util).to receive(:services).and_return(list_of_services)
+      service_util.expects(:services).returns(list_of_services)
 
       expect(provider_class.instances.map(&:name)).to match_array(['snmptrap', 'svchost', 'sshd'])
     end
@@ -31,24 +37,24 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#start" do
     before(:each) do
-      allow(provider).to receive(:status).and_return(:stopped)
+      provider.stubs(:status).returns(:stopped)
     end
 
     it "should resume a paused service" do
-      allow(provider).to receive(:status).and_return(:paused)
-      expect(service_util).to receive(:resume).with(name)
+      provider.stubs(:status).returns(:paused)
+      service_util.expects(:resume)
       provider.start
     end
 
     it "should start the service" do
-      expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_AUTO_START)
-      expect(service_util).to receive(:start).with(name)
+      service_util.expects(:service_start_type).with(name).returns(:SERVICE_AUTO_START)
+      service_util.expects(:start)
       provider.start
     end
 
     context "when the service is disabled" do
       before :each do
-        expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DISABLED)
+        service_util.expects(:service_start_type).with(name).returns(:SERVICE_DISABLED)
       end
 
       it "should refuse to start if not managing enable" do
@@ -57,16 +63,16 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
       it "should enable if managing enable and enable is true" do
         resource[:enable] = :true
-        expect(service_util).to receive(:start).with(name)
-        expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START)
+        service_util.expects(:start)
+        service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START)
 
         provider.start
       end
 
       it "should manual start if managing enable and enable is false" do
         resource[:enable] = :false
-        expect(service_util).to receive(:start).with(name)
-        expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
+        service_util.expects(:start)
+        service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
 
         provider.start
       end
@@ -75,7 +81,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#stop" do
     it "should stop a running service" do
-      expect(service_util).to receive(:stop).with(name)
+      service_util.expects(:stop)
 
       provider.stop
     end
@@ -83,7 +89,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#status" do
     it "should report a nonexistent service as stopped" do
-      allow(service_util).to receive(:exists?).with(resource[:name]).and_return(false)
+      service_util.stubs(:exists?).with(resource[:name]).returns(false)
 
       expect(provider.status).to eql(:stopped)
     end
@@ -93,7 +99,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
       :SERVICE_PAUSE_PENDING
     ].each do |state|
       it "should report a #{state} service as paused" do
-        expect(service_util).to receive(:service_state).with(name).and_return(state)
+        service_util.expects(:service_state).with(name).returns(state)
         expect(provider.status).to eq(:paused)
       end
     end
@@ -103,7 +109,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
       :SERVICE_STOP_PENDING
     ].each do |state|
       it "should report a #{state} service as stopped" do
-        expect(service_util).to receive(:service_state).with(name).and_return(state)
+        service_util.expects(:service_state).with(name).returns(state)
         expect(provider.status).to eq(:stopped)
       end
     end
@@ -114,7 +120,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
       :SERVICE_START_PENDING,
     ].each do |state|
       it "should report a #{state} service as running" do
-        expect(service_util).to receive(:service_state).with(name).and_return(state)
+        service_util.expects(:service_state).with(name).returns(state)
 
         expect(provider.status).to eq(:running)
       end
@@ -125,14 +131,16 @@ describe 'Puppet::Type::Service::Provider::Windows',
     it "should use the supplied restart command if specified" do
       resource[:restart] = 'c:/bin/foo'
 
-      expect(provider).to receive(:execute).with(['c:/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).never
+      provider.expects(:execute).with(['c:/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
 
       provider.restart
     end
 
     it "should restart the service" do
-      expect(provider).to receive(:stop).ordered
-      expect(provider).to receive(:start).ordered
+      seq = sequence("restarting")
+      provider.expects(:stop).in_sequence(seq)
+      provider.expects(:start).in_sequence(seq)
 
       provider.restart
     end
@@ -140,18 +148,18 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#enabled?" do
     it "should report a nonexistent service as false" do
-      allow(service_util).to receive(:exists?).with(resource[:name]).and_return(false)
+      service_util.stubs(:exists?).with(resource[:name]).returns(false)
 
       expect(provider.enabled?).to eql(:false)
     end
 
     it "should report a service with a startup type of manual as manual" do
-      expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DEMAND_START)
+      service_util.expects(:service_start_type).with(name).returns(:SERVICE_DEMAND_START)
       expect(provider.enabled?).to eq(:manual)
     end
 
     it "should report a service with a startup type of disabled as false" do
-      expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DISABLED)
+      service_util.expects(:service_start_type).with(name).returns(:SERVICE_DISABLED)
       expect(provider.enabled?).to eq(:false)
     end
 
@@ -164,7 +172,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
         :SERVICE_SYSTEM_START
       ].each do |start_type|
         it "should report a service with a startup type of '#{start_type}' as true" do
-          expect(service_util).to receive(:service_start_type).with(name).and_return(start_type)
+          service_util.expects(:service_start_type).with(name).returns(start_type)
           expect(provider.enabled?).to eq(:true)
         end
       end
@@ -173,12 +181,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#enable" do
     it "should set service start type to Service_Auto_Start when enabled" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START)
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START)
       provider.enable
     end
 
     it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START).and_raise(Puppet::Error.new('foobar'))
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START).raises(Puppet::Error.new('foobar'))
 
       expect {
         provider.enable
@@ -188,12 +196,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#disable" do
     it "should set service start type to Service_Disabled when disabled" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DISABLED)
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DISABLED)
       provider.disable
     end
 
     it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DISABLED).and_raise(Puppet::Error.new('foobar'))
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DISABLED).raises(Puppet::Error.new('foobar'))
 
       expect {
         provider.disable
@@ -203,12 +211,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#manual_start" do
     it "should set service start type to Service_Demand_Start (manual) when manual" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
       provider.manual_start
     end
 
     it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START).and_raise(Puppet::Error.new('foobar'))
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START).raises(Puppet::Error.new('foobar'))
 
       expect {
         provider.manual_start