puppet 6.4.0-x64-mingw32 → 6.4.1-x64-mingw32

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platform.jruby? do
@@ -23,13 +22,13 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
   end
 
   def lists_processes_as(output)
-    Puppet::Util::Execution.stubs(:execpipe).with("/sbin/initctl list").yields(output)
-    provider_class.stubs(:which).with("/sbin/initctl").returns("/sbin/initctl")
+    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")
   end
 
   it "should be the default provider on Ubuntu" do
-    Facter.expects(:value).with(:operatingsystem).returns("Ubuntu")
-    Facter.expects(:value).with(:operatingsystemmajrelease).returns("12.04")
+    expect(Facter).to receive(:value).with(:operatingsystem).and_return("Ubuntu")
+    expect(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("12.04")
     expect(provider_class.default?).to be_truthy
   end
 
@@ -48,9 +47,10 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
     end
 
     let(:initctl_version) { ['/sbin/initctl', 'version', '--quiet'] }
+
     before(:each) do
       # Stub out /sbin/initctl
-      Puppet::Util.stubs(:which).with('/sbin/initctl').returns('/sbin/initctl')
+      allow(Puppet::Util).to receive(:which).with('/sbin/initctl').and_return('/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.
@@ -60,14 +60,14 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
     end
 
     it "should return true when the daemon is running" do
-      Puppet::Util::Execution.expects(:execute).with(initctl_version, instance_of(Hash))
+      expect(Puppet::Util::Execution).to receive(: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
-      Puppet::Util::Execution.expects(:execute)
+      expect(Puppet::Util::Execution).to receive(:execute)
         .with(initctl_version, instance_of(Hash))
-        .raises(Puppet::ExecutionFailure, "initctl failed!")
+        .and_raise(Puppet::ExecutionFailure, "initctl failed!")
 
       assert_upstart_daemon_existence_confine_is(false)
     end
@@ -75,7 +75,7 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
 
   describe "excluding services" do
     it "ignores tty and serial on Redhat systems" do
-      Facter.stubs(:value).with(:osfamily).returns('RedHat')
+      allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
       expect(provider_class.excludes).to include 'serial'
       expect(provider_class.excludes).to include 'tty'
     end
@@ -96,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)"
-      provider_class.stubs(:execpipe).yields(processes)
+      allow(provider_class).to receive(:execpipe).and_yield(processes)
       expect(provider_class.instances.first.name).to eq("network-interface-security JOB=network-interface/eth0")
     end
 
@@ -108,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"
-      provider_class.stubs(:execpipe).yields(processes)
+      allow(provider_class).to receive(:execpipe).and_yield(processes)
       expect(provider_class.instances).to be_empty
     end
   end
 
   describe "#search" do
     it "searches through paths to find a matching conf file" do
-      File.stubs(:directory?).returns(true)
-      Puppet::FileSystem.stubs(:exist?).returns(false)
-      Puppet::FileSystem.expects(:exist?).with("/etc/init/foo-bar.conf").returns(true)
+      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)
       resource = Puppet::Type.type(:service).new(:name => "foo-bar", :provider => :upstart)
       provider = provider_class.new(resource)
 
@@ -125,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
-      File.stubs(:directory?).returns(true)
-      Puppet::FileSystem.stubs(:exist?).returns(false)
-      Puppet::FileSystem.expects(:exist?).with("/etc/init/network-interface.conf").returns(true)
+      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)
       resource = Puppet::Type.type(:service).new(:name => "network-interface INTERFACE=lo", :provider => :upstart)
       provider = provider_class.new(resource)
 
@@ -139,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)
-      provider.stubs(:is_upstart?).returns(true)
+      allow(provider).to receive(:is_upstart?).and_return(true)
 
-      provider.expects(:status_exec).with(["foo"]).returns("foo start/running, process 1000")
-      Process::Status.any_instance.stubs(:exitstatus).returns(0)
+      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)
       expect(provider.status).to eq(:running)
     end
 
@@ -150,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)
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(true)
 
-        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)
+        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.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)
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(true)
 
-        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).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)
         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)
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(true)
 
-        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).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)
         expect(provider.status).to eq(:running)
       end
     end
@@ -185,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)
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(true)
 
-        provider.expects(:status_exec).with(['foo']).never
-        provider.expects(:getpid).returns nil
+        expect(provider).not_to receive(:status_exec).with(['foo'])
+        expect(provider).to receive(:getpid).and_return(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)
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(true)
 
-        provider.expects(:status_exec).with(['foo']).never
-        provider.expects(:getpid).returns 2706
+        expect(provider).not_to receive(:status_exec).with(['foo'])
+        expect(provider).to receive(:getpid).and_return(2706)
         expect(provider.status).to eq(:running)
       end
     end
@@ -207,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)
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(true)
 
-        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)
+        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.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)
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(true)
 
-        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).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)
         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)
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(true)
 
-        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).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)
         expect(provider.status).to eq(:running)
       end
     end
@@ -242,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)
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(true)
 
-        provider.expects(:status_exec).with(['foo']).never
-        provider.expects(:getpid).returns nil
+        expect(provider).not_to receive(:status_exec).with(['foo'])
+        expect(provider).to receive(:getpid).and_return(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)
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(true)
 
-        provider.expects(:status_exec).with(['foo']).never
-        provider.expects(:getpid).returns 2706
+        expect(provider).not_to receive(:status_exec).with(['foo'])
+        expect(provider).to receive(:getpid).and_return(2706)
         expect(provider.status).to eq(:running)
       end
     end
@@ -263,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)
-      provider.stubs(:is_upstart?).returns(true)
+      allow(provider).to receive(:is_upstart?).and_return(true)
 
-      provider.expects(:status_exec).with(["foostartbar"]).returns("foostartbar stop/waiting")
-      Process::Status.any_instance.stubs(:exitstatus).returns(0)
+      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)
       expect(provider.status).to eq(:stopped)
     end
   end
@@ -282,13 +282,15 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
 
     describe "when upstart job" do
       before(:each) do
-        provider.stubs(:is_upstart?).returns(true)
+        allow(provider).to receive(:is_upstart?).and_return(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
@@ -367,9 +369,9 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
 
     describe "Upstart version < 0.6.7" do
       before(:each) do
-        provider.stubs(:is_upstart?).returns(true)
-        provider.stubs(:upstart_version).returns("0.6.5")
-        provider.stubs(:search).returns(init_script)
+        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)
       end
 
       [:enabled?,:enable,:disable].each do |enableable|
@@ -453,9 +455,9 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
 
     describe "Upstart version < 0.9.0" do
       before(:each) do
-        provider.stubs(:is_upstart?).returns(true)
-        provider.stubs(:upstart_version).returns("0.7.0")
-        provider.stubs(:search).returns(init_script)
+        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)
       end
 
       [:enabled?,:enable,:disable].each do |enableable|
@@ -571,10 +573,10 @@ describe 'Puppet::Type::Service::Provider::Upstart', unless: Puppet::Util::Platf
 
     describe "Upstart version > 0.9.0" do
       before(:each) do
-        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)
+        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)
       end
 
       [:enabled?,:enable,:disable].each do |enableable|
@@ -672,6 +674,7 @@ 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,10 +1,4 @@
-#! /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',
@@ -16,20 +10,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) { mock() }
+  let(:service_handle) { double() }
 
   before :each do
     # make sure we never actually execute anything (there are two execute methods)
-    provider.class.expects(:execute).never
-    provider.expects(:execute).never
+    allow(provider.class).to receive(:execute)
+    allow(provider).to receive(:execute)
 
-    service_util.stubs(:exists?).with(resource[:name]).returns(true)
+    allow(service_util).to receive(:exists?).with(resource[:name]).and_return(true)
   end
 
   describe ".instances" do
     it "should enumerate all services" do
       list_of_services = {'snmptrap' => {}, 'svchost' => {}, 'sshd' => {}}
-      service_util.expects(:services).returns(list_of_services)
+      expect(service_util).to receive(:services).and_return(list_of_services)
 
       expect(provider_class.instances.map(&:name)).to match_array(['snmptrap', 'svchost', 'sshd'])
     end
@@ -37,24 +31,24 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#start" do
     before(:each) do
-      provider.stubs(:status).returns(:stopped)
+      allow(provider).to receive(:status).and_return(:stopped)
     end
 
     it "should resume a paused service" do
-      provider.stubs(:status).returns(:paused)
-      service_util.expects(:resume)
+      allow(provider).to receive(:status).and_return(:paused)
+      expect(service_util).to receive(:resume)
       provider.start
     end
 
     it "should start the service" do
-      service_util.expects(:service_start_type).with(name).returns(:SERVICE_AUTO_START)
-      service_util.expects(:start)
+      expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_AUTO_START)
+      expect(service_util).to receive(:start)
       provider.start
     end
 
     context "when the service is disabled" do
       before :each do
-        service_util.expects(:service_start_type).with(name).returns(:SERVICE_DISABLED)
+        expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DISABLED)
       end
 
       it "should refuse to start if not managing enable" do
@@ -63,16 +57,16 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
       it "should enable if managing enable and enable is true" do
         resource[:enable] = :true
-        service_util.expects(:start)
-        service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START)
+        expect(service_util).to receive(:start)
+        expect(service_util).to receive(: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
-        service_util.expects(:start)
-        service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
+        expect(service_util).to receive(:start)
+        expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
 
         provider.start
       end
@@ -81,7 +75,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#stop" do
     it "should stop a running service" do
-      service_util.expects(:stop)
+      expect(service_util).to receive(:stop)
 
       provider.stop
     end
@@ -89,7 +83,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#status" do
     it "should report a nonexistent service as stopped" do
-      service_util.stubs(:exists?).with(resource[:name]).returns(false)
+      allow(service_util).to receive(:exists?).with(resource[:name]).and_return(false)
 
       expect(provider.status).to eql(:stopped)
     end
@@ -99,7 +93,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
       :SERVICE_PAUSE_PENDING
     ].each do |state|
       it "should report a #{state} service as paused" do
-        service_util.expects(:service_state).with(name).returns(state)
+        expect(service_util).to receive(:service_state).with(name).and_return(state)
         expect(provider.status).to eq(:paused)
       end
     end
@@ -109,7 +103,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
       :SERVICE_STOP_PENDING
     ].each do |state|
       it "should report a #{state} service as stopped" do
-        service_util.expects(:service_state).with(name).returns(state)
+        expect(service_util).to receive(:service_state).with(name).and_return(state)
         expect(provider.status).to eq(:stopped)
       end
     end
@@ -120,7 +114,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
       :SERVICE_START_PENDING,
     ].each do |state|
       it "should report a #{state} service as running" do
-        service_util.expects(:service_state).with(name).returns(state)
+        expect(service_util).to receive(:service_state).with(name).and_return(state)
 
         expect(provider.status).to eq(:running)
       end
@@ -131,16 +125,14 @@ describe 'Puppet::Type::Service::Provider::Windows',
     it "should use the supplied restart command if specified" do
       resource[:restart] = 'c:/bin/foo'
 
-      provider.expects(:execute).never
-      provider.expects(:execute).with(['c:/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['c:/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
 
       provider.restart
     end
 
     it "should restart the service" do
-      seq = sequence("restarting")
-      provider.expects(:stop).in_sequence(seq)
-      provider.expects(:start).in_sequence(seq)
+      expect(provider).to receive(:stop).ordered
+      expect(provider).to receive(:start).ordered
 
       provider.restart
     end
@@ -148,18 +140,18 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#enabled?" do
     it "should report a nonexistent service as false" do
-      service_util.stubs(:exists?).with(resource[:name]).returns(false)
+      allow(service_util).to receive(:exists?).with(resource[:name]).and_return(false)
 
       expect(provider.enabled?).to eql(:false)
     end
 
     it "should report a service with a startup type of manual as manual" do
-      service_util.expects(:service_start_type).with(name).returns(:SERVICE_DEMAND_START)
+      expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DEMAND_START)
       expect(provider.enabled?).to eq(:manual)
     end
 
     it "should report a service with a startup type of disabled as false" do
-      service_util.expects(:service_start_type).with(name).returns(:SERVICE_DISABLED)
+      expect(service_util).to receive(:service_start_type).with(name).and_return(:SERVICE_DISABLED)
       expect(provider.enabled?).to eq(:false)
     end
 
@@ -172,7 +164,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
-          service_util.expects(:service_start_type).with(name).returns(start_type)
+          expect(service_util).to receive(:service_start_type).with(name).and_return(start_type)
           expect(provider.enabled?).to eq(:true)
         end
       end
@@ -181,12 +173,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#enable" do
     it "should set service start type to Service_Auto_Start when enabled" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START)
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START)
       provider.enable
     end
 
     it "raises an error if set_startup_mode fails" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START).raises(Puppet::Error.new('foobar'))
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.enable
@@ -196,12 +188,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#disable" do
     it "should set service start type to Service_Disabled when disabled" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_DISABLED)
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DISABLED)
       provider.disable
     end
 
     it "raises an error if set_startup_mode fails" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_DISABLED).raises(Puppet::Error.new('foobar'))
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DISABLED).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.disable
@@ -211,12 +203,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
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
       provider.manual_start
     end
 
     it "raises an error if set_startup_mode fails" do
-      service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START).raises(Puppet::Error.new('foobar'))
+      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.manual_start