puppet 5.5.12 → 5.5.13

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

@@ -1,11 +1,6 @@
-#! /usr/bin/env ruby
-#
-# Unit testing for the systemd service Provider
-#
 require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:systemd) do
-
   if Puppet.features.microsoft_windows?
     # Get a pid for $CHILD_STATUS to latch on to
     command = "cmd.exe /c \"exit 0\""
@@ -13,8 +8,8 @@ describe Puppet::Type.type(:service).provider(:systemd) do
   end
 
   before :each do
-    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
-    described_class.stubs(:which).with('systemctl').returns '/bin/systemctl'
+    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(described_class)
+    allow(described_class).to receive(:which).with('systemctl').and_return('/bin/systemctl')
   end
 
   let :provider do
@@ -25,15 +20,15 @@ describe Puppet::Type.type(:service).provider(:systemd) do
 
   osfamilies.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
-      Facter.stubs(:value).with(:osfamily).returns(osfamily)
+      allow(Facter).to receive(:value).with(:osfamily).and_return(osfamily)
       expect(described_class).to be_default
     end
   end
 
   [7, 8].each do |ver|
     it "should be the default provider on rhel#{ver}" do
-      Facter.stubs(:value).with(:osfamily).returns(:redhat)
-      Facter.stubs(:value).with(:operatingsystemmajrelease).returns(ver.to_s)
+      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return(ver.to_s)
       expect(described_class).to be_default
     end
   end
@@ -42,97 +37,97 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     it "should not be the default provider on rhel#{ver}" do
       # 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}")
+      # provider. As a workaround we need to use allow() instead of
+      # expect() here.
+      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}")
       expect(described_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
-      Facter.stubs(:value).with(:osfamily).returns(:redhat)
-      Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
-      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+      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}")
       expect(described_class).to be_default
     end
   end
 
   it "should be the default provider on Amazon Linux 2.0" do
-    Facter.stubs(:value).with(:osfamily).returns(:redhat)
-    Facter.stubs(:value).with(:operatingsystem).returns(:amazon)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("2")
+    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")
     expect(described_class).to be_default
   end
 
   it "should not be the default provider on Amazon Linux 2017.09" do
-    Facter.stubs(:value).with(:osfamily).returns(:redhat)
-    Facter.stubs(:value).with(:operatingsystem).returns(:amazon)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("2017")
+    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")
     expect(described_class).not_to be_default
   end
 
   it "should be the default provider on cumulus3" do
-    Facter.stubs(:value).with(:osfamily).returns(:debian)
-    Facter.stubs(:value).with(:operatingsystem).returns('CumulusLinux')
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("3")
+    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")
     expect(described_class).to be_default
   end
 
   it "should be the default provider on sles12" do
-    Facter.stubs(:value).with(:osfamily).returns(:suse)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("12")
+    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
+    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("12")
     expect(described_class).to be_default
   end
 
   it "should be the default provider on opensuse13" do
-    Facter.stubs(:value).with(:osfamily).returns(:suse)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("13")
+    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
+    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("13")
     expect(described_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
-    Facter.stubs(:value).with(:osfamily).returns(:suse)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("20150829")
+    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
+    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("20150829")
     expect(described_class).to be_default
   end
 
   # leap is the next generation suse release
   it "should be the default provider on leap" do
-    Facter.stubs(:value).with(:osfamily).returns(:suse)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("42")
+    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
+    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("42")
     expect(described_class).to be_default
   end
 
   it "should not be the default provider on debian7" do
-    Facter.stubs(:value).with(:osfamily).returns(:debian)
-    Facter.stubs(:value).with(:operatingsystem).returns(:debian)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
+    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")
     expect(described_class).not_to be_default
   end
 
   it "should be the default provider on debian8" do
-    Facter.stubs(:value).with(:osfamily).returns(:debian)
-    Facter.stubs(:value).with(:operatingsystem).returns(:debian)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8")
+    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")
     expect(described_class).to be_default
   end
 
   it "should not be the default provider on ubuntu14.04" do
-    Facter.stubs(:value).with(:osfamily).returns(:debian)
-    Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("14.04")
+    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")
     expect(described_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
-      Facter.stubs(:value).with(:osfamily).returns(:debian)
-      Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
-      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+      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}")
       expect(described_class).to be_default
     end
   end
@@ -149,7 +144,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     end
 
     it "should return only services" do
-      described_class.expects(:systemctl).with('list-unit-files', '--type', 'service', '--full', '--all', '--no-pager').returns File.read(my_fixture('list_unit_files_services'))
+      expect(described_class).to receive(:systemctl).with('list-unit-files', '--type', 'service', '--full', '--all', '--no-pager').and_return(File.read(my_fixture('list_unit_files_services')))
       expect(described_class.instances.map(&:name)).to match_array(%w{
         arp-ethers.service
         auditd.service
@@ -163,29 +158,29 @@ describe Puppet::Type.type(:service).provider(:systemd) do
   describe "#start" do
     it "should use the supplied start command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :start => '/bin/foo'))
-      provider.expects(:execute).with(['/bin/foo'], :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.start
     end
 
     it "should start the service with systemctl start otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with(:unmask, 'sshd.service')
-      provider.expects(:execute).with(['/bin/systemctl','start','sshd.service'], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+      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.start
     end
 
     it "should show journald logs on failure" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with(:unmask, 'sshd.service')
-      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.")
+      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.")
       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
-      provider.expects(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").returns(journalctl_logs)
+      expect(provider).to receive(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").and_return(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
@@ -193,27 +188,27 @@ 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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :stop => '/bin/foo'))
-      provider.expects(:execute).with(['/bin/foo'], :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.stop
     end
 
     it "should stop the service with systemctl stop otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:execute).with(['/bin/systemctl','stop','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(: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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      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.")
+      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.")
       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
-      provider.expects(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").returns(journalctl_logs)
+      expect(provider).to receive(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").and_return(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
@@ -221,43 +216,43 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#enabled?" do
     it "should return :true if the service is enabled" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "enabled\n"
-      $CHILD_STATUS.stubs(:exitstatus).returns(0)
+      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)
       expect(provider.enabled?).to eq(:true)
     end
 
     it "should return :true if the service is static" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "static\n"
-      $CHILD_STATUS.stubs(:exitstatus).returns(0)
+      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)
       expect(provider.enabled?).to eq(:true)
     end
 
     it "should return :false if the service is disabled" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "disabled\n"
-      $CHILD_STATUS.stubs(:exitstatus).returns(1)
+      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)
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return :false if the service is indirect" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "indirect\n"
-      $CHILD_STATUS.stubs(:exitstatus).returns(0)
+      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)
       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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => false))
-      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "masked\n"
-      $CHILD_STATUS.stubs(:exitstatus).returns(1)
+      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)
       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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => 'mask'))
-      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "masked\n"
-      $CHILD_STATUS.stubs(:exitstatus).returns(1)
+      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)
       expect(provider.enabled?).to eq(:mask)
     end
   end
@@ -265,8 +260,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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with(:unmask, 'sshd.service')
-      provider.expects(:systemctl).with(:enable, 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:unmask, 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:enable, 'sshd.service')
       provider.enable
     end
   end
@@ -274,7 +269,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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with(:disable, 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:disable, 'sshd.service')
       provider.disable
     end
   end
@@ -285,8 +280,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.
-      provider.expects(:systemctl).with(:disable, 'sshd.service')
-      provider.expects(:systemctl).with(:mask, 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:disable, 'sshd.service')
+      expect(provider).to receive(:systemctl).with(:mask, 'sshd.service')
       provider.mask
     end
   end
@@ -296,23 +291,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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      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).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)
       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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        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).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)
         expect(provider.status).to eq(:stopped)
       end
     }
 
     it "should use the supplied status command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :status => '/bin/foo'))
-      provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
       provider.status
     end
   end
@@ -322,28 +317,28 @@ 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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
-      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)
+      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.restart
     end
 
     it "should restart the service with systemctl restart" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:execute).with(['/bin/systemctl','restart','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(: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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      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.")
+      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.")
       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
-      provider.expects(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").returns(journalctl_logs)
+      expect(provider).to receive(:execute).with("journalctl -n 50 --since '5 minutes ago' -u sshd.service --no-pager").and_return(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
@@ -352,8 +347,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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        provider.stubs(:system)
-        $CHILD_STATUS.expects(:exitstatus).returns(status)
+        allow(provider).to receive(:system)
+        expect($CHILD_STATUS).to receive(:exitstatus).and_return(status)
         expect(provider.debian_enabled?).to eq(:true)
       end
     end
@@ -361,17 +356,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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        provider.stubs(:system)
-        provider.expects(:get_start_link_count).returns(4)
-        $CHILD_STATUS.expects(:exitstatus).twice.returns(status)
+        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)
         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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        provider.stubs(:system)
-        provider.expects(:get_start_link_count).returns(1)
-        $CHILD_STATUS.expects(:exitstatus).twice.returns(status)
+        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)
         expect(provider.debian_enabled?).to eq(:false)
       end
     end
@@ -380,13 +375,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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      Dir.expects(:glob).with("/etc/rc*.d/S??sshd").returns(['files'])
+      expect(Dir).to receive(:glob).with("/etc/rc*.d/S??sshd").and_return(['files'])
       provider.get_start_link_count
     end
 
     it "should use the full service name if it does not include '.service'" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      Dir.expects(:glob).with("/etc/rc*.d/S??sshd").returns(['files'])
+      expect(Dir).to receive(:glob).with("/etc/rc*.d/S??sshd").and_return(['files'])
       provider.get_start_link_count
     end
   end

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

@@ -1,7 +1,5 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-
 describe Puppet::Type.type(:service).provider(:upstart) do
   let(:manual) { "\nmanual" }
   let(:start_on_default_runlevels) {  "\nstart on runlevel [2,3,4,5]" }
@@ -24,13 +22,13 @@ describe Puppet::Type.type(:service).provider(:upstart) do
   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(described_class.default?).to be_truthy
   end
 
@@ -46,9 +44,10 @@ describe Puppet::Type.type(:service).provider(:upstart) do
     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.
@@ -58,14 +57,14 @@ describe Puppet::Type.type(:service).provider(:upstart) do
     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
@@ -73,7 +72,7 @@ describe Puppet::Type.type(:service).provider(:upstart) do
 
   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(described_class.excludes).to include 'serial'
       expect(described_class.excludes).to include 'tty'
     end
@@ -94,7 +93,7 @@ describe Puppet::Type.type(:service).provider(:upstart) do
 
     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
 
@@ -106,16 +105,16 @@ describe Puppet::Type.type(:service).provider(:upstart) do
       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)
 
@@ -123,9 +122,9 @@ describe Puppet::Type.type(:service).provider(:upstart) do
     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)
 
@@ -137,10 +136,10 @@ describe Puppet::Type.type(:service).provider(:upstart) do
     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
 
@@ -148,33 +147,33 @@ describe Puppet::Type.type(:service).provider(:upstart) do
       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
@@ -183,20 +182,20 @@ describe Puppet::Type.type(:service).provider(:upstart) do
       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
@@ -205,33 +204,33 @@ describe Puppet::Type.type(:service).provider(:upstart) do
       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
@@ -240,20 +239,20 @@ describe Puppet::Type.type(:service).provider(:upstart) do
       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
@@ -261,10 +260,10 @@ describe Puppet::Type.type(:service).provider(:upstart) do
     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
@@ -280,13 +279,15 @@ describe Puppet::Type.type(:service).provider(:upstart) do
 
     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
@@ -365,9 +366,9 @@ describe Puppet::Type.type(:service).provider(:upstart) do
 
     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|
@@ -451,9 +452,9 @@ describe Puppet::Type.type(:service).provider(:upstart) do
 
     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|
@@ -569,10 +570,10 @@ describe Puppet::Type.type(:service).provider(:upstart) do
 
     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|
@@ -670,6 +671,7 @@ describe Puppet::Type.type(:service).provider(:upstart) do
             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)