puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

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

@@ -1,7 +1,12 @@
+#! /usr/bin/env ruby
+#
+# Unit testing for the systemd service Provider
+#
 require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platform.jruby? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:systemd) }
+
   if Puppet::Util::Platform.windows?
     # Get a pid for $CHILD_STATUS to latch on to
     command = "cmd.exe /c \"exit 0\""
@@ -9,8 +14,8 @@ describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platf
   end
 
   before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
-    allow(provider_class).to receive(:which).with('systemctl').and_return('/bin/systemctl')
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns provider_class
+    provider_class.stubs(:which).with('systemctl').returns '/bin/systemctl'
   end
 
   let :provider do
@@ -21,140 +26,142 @@ describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platf
 
   osfamilies.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(osfamily)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(osfamily)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("1234")
+      Facter.stubs(:value).with(:osfamily).returns(osfamily)
+      Facter.stubs(:value).with(:operatingsystem).returns(osfamily)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("1234")
       expect(provider_class).to be_default
     end
   end
 
-  [7, 8].each do |ver|
-    it "should be the default provider on rhel#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return(ver.to_s)
-      expect(provider_class).to be_default
-    end
+  it "should be the default provider on rhel7" do
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
+    expect(provider_class).to be_default
   end
 
   [ 4, 5, 6 ].each do |ver|
     it "should not be the default provider on rhel#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
+      # In Ruby 1.8.7, the order of hash elements differs from 1.9+ and
+      # caused short-circuiting of the logic used by default.all? in the
+      # provider. As a workaround we need to use stubs() instead of
+      # expects() here.
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
       expect(provider_class).not_to be_default
     end
   end
 
   [ 17, 18, 19, 20, 21, 22, 23 ].each do |ver|
     it "should be the default provider on fedora#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
       expect(provider_class).to be_default
     end
   end
 
   it "should be the default provider on Amazon Linux 2.0" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:amazon)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("2")
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystem).returns(:amazon)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("2")
     expect(provider_class).to be_default
   end
 
   it "should not be the default provider on Amazon Linux 2017.09" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:amazon)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("2017")
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystem).returns(:amazon)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("2017")
     expect(provider_class).not_to be_default
   end
 
   it "should be the default provider on cumulus3" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return('CumulusLinux')
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("3")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns('CumulusLinux')
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("3")
     expect(provider_class).to be_default
   end
 
   it "should be the default provider on sles12" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("12")
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystem).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("12")
     expect(provider_class).to be_default
   end
 
   it "should be the default provider on opensuse13" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("13")
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystem).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("13")
     expect(provider_class).to be_default
   end
 
   # tumbleweed is a rolling release with date-based major version numbers
   it "should be the default provider on tumbleweed" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("20150829")
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystem).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("20150829")
     expect(provider_class).to be_default
   end
 
   # leap is the next generation suse release
   it "should be the default provider on leap" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:leap)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("42")
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystem).returns(:leap)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("42")
     expect(provider_class).to be_default
   end
 
   it "should not be the default provider on debian7" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("7")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
     expect(provider_class).not_to be_default
   end
 
   it "should be the default provider on debian8" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("8")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8")
     expect(provider_class).to be_default
   end
 
   it "should not be the default provider on ubuntu14.04" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:ubuntu)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("14.04")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("14.04")
     expect(provider_class).not_to be_default
   end
 
   [ '15.04', '15.10', '16.04', '16.10', '17.04', '17.10', '18.04' ].each do |ver|
     it "should be the default provider on ubuntu#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:ubuntu)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
+      Facter.stubs(:value).with(:osfamily).returns(:debian)
+      Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
       expect(provider_class).to be_default
     end
   end
 
   [ '10', '11', '12', '13', '14', '15', '16', '17' ].each do |ver|
     it "should not be the default provider on LinuxMint#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:LinuxMint)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
+      Facter.stubs(:value).with(:osfamily).returns(:debian)
+      Facter.stubs(:value).with(:operatingsystem).returns(:LinuxMint)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
       expect(provider_class).not_to be_default
     end
   end
 
   [ '18', '19' ].each do |ver|
     it "should be the default provider on LinuxMint#{ver}" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:debian)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:LinuxMint)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
+      Facter.stubs(:value).with(:osfamily).returns(:debian)
+      Facter.stubs(:value).with(:operatingsystem).returns(:LinuxMint)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
       expect(provider_class).to be_default
     end
   end
 
-  [:enabled?, :enable, :disable, :start, :stop, :status, :restart].each do |method|
+  [:enabled?, :daemon_reload?, :enable, :disable, :start, :stop, :status, :restart].each do |method|
     it "should have a #{method} method" do
       expect(provider).to respond_to(method)
     end
@@ -166,7 +173,7 @@ describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platf
     end
 
     it "should return only services" do
-      expect(provider_class).to receive(:systemctl).with('list-unit-files', '--type', 'service', '--full', '--all', '--no-pager').and_return(File.read(my_fixture('list_unit_files_services')))
+      provider_class.expects(:systemctl).with('list-unit-files', '--type', 'service', '--full', '--all', '--no-pager').returns File.read(my_fixture('list_unit_files_services'))
       expect(provider_class.instances.map(&:name)).to match_array(%w{
         arp-ethers.service
         auditd.service
@@ -180,29 +187,32 @@ describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platf
   describe "#start" do
     it "should use the supplied start command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :start => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:daemon_reload?).returns('no')
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
 
     it "should start the service with systemctl start otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:systemctl).with(:unmask, 'sshd.service')
-      expect(provider).to receive(:execute).with(['/bin/systemctl','start','sshd.service'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+      provider.expects(:systemctl).with(:unmask, 'sshd.service')
+      provider.expects(:daemon_reload?).returns('no')
+      provider.expects(:execute).with(['/bin/systemctl','start','sshd.service'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
       provider.start
     end
 
     it "should show journald logs on failure" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:systemctl).with(:unmask, 'sshd.service')
-      expect(provider).to receive(:execute).with(['/bin/systemctl','start','sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-        .and_raise(Puppet::ExecutionFailure, "Failed to start sshd.service: Unit sshd.service failed to load: Invalid argument. See system logs and 'systemctl status sshd.service' for details.")
+      provider.expects(:systemctl).with(:unmask, 'sshd.service')
+      provider.expects(:daemon_reload?).returns('no')
+      provider.expects(:execute).with(['/bin/systemctl','start','sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+        .raises(Puppet::ExecutionFailure, "Failed to start sshd.service: Unit sshd.service failed to load: Invalid argument. See system logs and 'systemctl status sshd.service' for details.")
       journalctl_logs = <<-EOS
 -- Logs begin at Tue 2016-06-14 11:59:21 UTC, end at Tue 2016-06-14 21:45:02 UTC. --
 Jun 14 21:41:34 foo.example.com systemd[1]: Stopping sshd Service...
 Jun 14 21:41:35 foo.example.com systemd[1]: Starting sshd Service...
 Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= and ExecStop= setting. Refusing.
       EOS
-      expect(provider).to receive(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").and_return(journalctl_logs)
+      provider.expects(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").returns(journalctl_logs)
       expect { provider.start }.to raise_error(Puppet::Error, /Systemd start for sshd.service failed![\n]+journalctl log for sshd.service:[\n]+-- Logs begin at Tue 2016-06-14 11:59:21 UTC, end at Tue 2016-06-14 21:45:02 UTC. --/m)
     end
   end
@@ -210,71 +220,85 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#stop" do
     it "should use the supplied stop command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :stop => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
 
     it "should stop the service with systemctl stop otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','stop','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/bin/systemctl','stop','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
 
     it "should show journald logs on failure" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','stop','sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-        .and_raise(Puppet::ExecutionFailure, "Failed to stop sshd.service: Unit sshd.service failed to load: Invalid argument. See system logs and 'systemctl status sshd.service' for details.")
+      provider.expects(:execute).with(['/bin/systemctl','stop','sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+        .raises(Puppet::ExecutionFailure, "Failed to stop sshd.service: Unit sshd.service failed to load: Invalid argument. See system logs and 'systemctl status sshd.service' for details.")
       journalctl_logs = <<-EOS
 -- Logs begin at Tue 2016-06-14 11:59:21 UTC, end at Tue 2016-06-14 21:45:02 UTC. --
 Jun 14 21:41:34 foo.example.com systemd[1]: Stopping sshd Service...
 Jun 14 21:41:35 foo.example.com systemd[1]: Starting sshd Service...
 Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= and ExecStop= setting. Refusing.
       EOS
-      expect(provider).to receive(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").and_return(journalctl_logs)
+      provider.expects(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").returns(journalctl_logs)
       expect { provider.stop }.to raise_error(Puppet::Error, /Systemd stop for sshd.service failed![\n]+journalctl log for sshd.service:[\n]-- Logs begin at Tue 2016-06-14 11:59:21 UTC, end at Tue 2016-06-14 21:45:02 UTC. --/m)
     end
   end
 
+  describe "#daemon_reload?" do
+    it "should skip the systemctl daemon_reload if not required by the service" do
+      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:execute).with(['/bin/systemctl','show','sshd.service','--property=NeedDaemonReload'], :failonfail => false).returns "no"
+      provider.daemon_reload?
+    end
+    it "should run a systemctl daemon_reload if the service has been modified" do
+      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:execute).with(['/bin/systemctl','show','sshd.service','--property=NeedDaemonReload'], :failonfail => false).returns "yes"
+      provider.expects(:execute).with(['/bin/systemctl','daemon-reload'], :failonfail => false)
+      provider.daemon_reload?
+    end
+  end
+
   describe "#enabled?" do
     it "should return :true if the service is enabled" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("enabled\n")
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "enabled\n"
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       expect(provider.enabled?).to eq(:true)
     end
 
     it "should return :true if the service is static" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("static\n")
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "static\n"
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       expect(provider.enabled?).to eq(:true)
     end
 
     it "should return :false if the service is disabled" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("disabled\n")
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "disabled\n"
+      $CHILD_STATUS.stubs(:exitstatus).returns(1)
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return :false if the service is indirect" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("indirect\n")
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "indirect\n"
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return :false if the service is masked and the resource is attempting to be disabled" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => false))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("masked\n")
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "masked\n"
+      $CHILD_STATUS.stubs(:exitstatus).returns(1)
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return :mask if the service is masked and the resource is attempting to be masked" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => 'mask'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).and_return("masked\n")
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "masked\n"
+      $CHILD_STATUS.stubs(:exitstatus).returns(1)
       expect(provider.enabled?).to eq(:mask)
     end
   end
@@ -282,8 +306,8 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#enable" do
     it "should run systemctl enable to enable a service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:systemctl).with(:unmask, 'sshd.service')
-      expect(provider).to receive(:systemctl).with(:enable, 'sshd.service')
+      provider.expects(:systemctl).with(:unmask, 'sshd.service')
+      provider.expects(:systemctl).with(:enable, 'sshd.service')
       provider.enable
     end
   end
@@ -291,7 +315,7 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#disable" do
     it "should run systemctl disable to disable a service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:systemctl).with(:disable, 'sshd.service')
+      provider.expects(:systemctl).with(:disable, 'sshd.service')
       provider.disable
     end
   end
@@ -302,8 +326,8 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
       # :disable is the only call in the provider that uses a symbol instead of
       # a string.
       # This should be made consistent in the future and all tests updated.
-      expect(provider).to receive(:systemctl).with(:disable, 'sshd.service')
-      expect(provider).to receive(:systemctl).with(:mask, 'sshd.service')
+      provider.expects(:systemctl).with(:disable, 'sshd.service')
+      provider.expects(:systemctl).with(:mask, 'sshd.service')
       provider.mask
     end
   end
@@ -313,23 +337,23 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#status" do
     it "should return running if if the command returns 0" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-active','sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).and_return("active\n")
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+      provider.expects(:execute).with(['/bin/systemctl','is-active','sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).returns "active\n"
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       expect(provider.status).to eq(:running)
     end
 
     [-10,-1,3,10].each { |ec|
       it "should return stopped if the command returns something non-0" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        expect(provider).to receive(:execute).with(['/bin/systemctl','is-active','sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).and_return("inactive\n")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(ec)
+        provider.expects(:execute).with(['/bin/systemctl','is-active','sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).returns "inactive\n"
+        $CHILD_STATUS.stubs(:exitstatus).returns(ec)
         expect(provider.status).to eq(:stopped)
       end
     }
 
     it "should use the supplied status command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :status => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
       provider.status
     end
   end
@@ -339,28 +363,31 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#restart" do
     it "should use the supplied restart command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
-      expect(provider).not_to receive(:execute).with(['/bin/systemctl','restart','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:daemon_reload?).returns('no')
+      provider.expects(:execute).with(['/bin/systemctl','restart','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
 
     it "should restart the service with systemctl restart" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','restart','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:daemon_reload?).returns('no')
+      provider.expects(:execute).with(['/bin/systemctl','restart','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
 
     it "should show journald logs on failure" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','restart','sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
-        .and_raise(Puppet::ExecutionFailure, "Failed to restart sshd.service: Unit sshd.service failed to load: Invalid argument. See system logs and 'systemctl status sshd.service' for details.")
+      provider.expects(:daemon_reload?).returns('no')
+      provider.expects(:execute).with(['/bin/systemctl','restart','sshd.service'],{:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+        .raises(Puppet::ExecutionFailure, "Failed to restart sshd.service: Unit sshd.service failed to load: Invalid argument. See system logs and 'systemctl status sshd.service' for details.")
       journalctl_logs = <<-EOS
 -- Logs begin at Tue 2016-06-14 11:59:21 UTC, end at Tue 2016-06-14 21:45:02 UTC. --
 Jun 14 21:41:34 foo.example.com systemd[1]: Stopping sshd Service...
 Jun 14 21:41:35 foo.example.com systemd[1]: Starting sshd Service...
 Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= and ExecStop= setting. Refusing.
       EOS
-      expect(provider).to receive(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").and_return(journalctl_logs)
+      provider.expects(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").returns(journalctl_logs)
       expect { provider.restart }.to raise_error(Puppet::Error, /Systemd restart for sshd.service failed![\n]+journalctl log for sshd.service:[\n]+-- Logs begin at Tue 2016-06-14 11:59:21 UTC, end at Tue 2016-06-14 21:45:02 UTC. --/m)
     end
   end
@@ -369,8 +396,8 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
     [104, 106].each do |status|
       it "should return true when invoke-rc.d returns #{status}" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        allow(provider).to receive(:system)
-        expect($CHILD_STATUS).to receive(:exitstatus).and_return(status)
+        provider.stubs(:system)
+        $CHILD_STATUS.expects(:exitstatus).returns(status)
         expect(provider.debian_enabled?).to eq(:true)
       end
     end
@@ -378,17 +405,17 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
     [101, 105].each do |status|
       it "should return true when status is #{status} and there are at least 4 start links" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        allow(provider).to receive(:system)
-        expect(provider).to receive(:get_start_link_count).and_return(4)
-        expect($CHILD_STATUS).to receive(:exitstatus).twice.and_return(status)
+        provider.stubs(:system)
+        provider.expects(:get_start_link_count).returns(4)
+        $CHILD_STATUS.expects(:exitstatus).twice.returns(status)
         expect(provider.debian_enabled?).to eq(:true)
       end
 
       it "should return false when status is #{status} and there are less than 4 start links" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        allow(provider).to receive(:system)
-        expect(provider).to receive(:get_start_link_count).and_return(1)
-        expect($CHILD_STATUS).to receive(:exitstatus).twice.and_return(status)
+        provider.stubs(:system)
+        provider.expects(:get_start_link_count).returns(1)
+        $CHILD_STATUS.expects(:exitstatus).twice.returns(status)
         expect(provider.debian_enabled?).to eq(:false)
       end
     end
@@ -397,13 +424,13 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#get_start_link_count" do
     it "should strip the '.service' from the search if present in the resource name" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(Dir).to receive(:glob).with("/etc/rc*.d/S??sshd").and_return(['files'])
+      Dir.expects(:glob).with("/etc/rc*.d/S??sshd").returns(['files'])
       provider.get_start_link_count
     end
 
     it "should use the full service name if it does not include '.service'" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(Dir).to receive(:glob).with("/etc/rc*.d/S??sshd").and_return(['files'])
+      Dir.expects(:glob).with("/etc/rc*.d/S??sshd").returns(['files'])
       provider.get_start_link_count
     end
   end