install which command

Author: adrianiurca

.github/workflows/spec.yml

@@ -122,7 +122,7 @@ jobs:
       - name: Run Static & Syntax Tests
         run: |
           buildevents cmd $TRACE_ID $STEP_ID 'static_syntax_checks Puppet ${{ matrix.puppet_version }}, Ruby ${{ matrix.ruby_version }}' -- bundle exec rake syntax lint metadata_lint check:symlinks check:git_ignore check:dot_underscore check:test_file rubocop
-      
+
       - name: Run parallel_spec tests
         run: |
           buildevents cmd $TRACE_ID $STEP_ID 'rake parallel_spec Puppet ${{ matrix.puppet_version }}, Ruby ${{ matrix.ruby_version }}' -- bundle exec rake parallel_spec

spec/spec_helper_acceptance_local.rb

@@ -19,6 +19,8 @@ class CommandFailure < StandardError; end
 # shutdown command on $PATH with the script defined in LINUX_SHUTDOWN_SCRIPT, which will output the args passed to it
 # from the Agent. We will then verify that these args are what we expect.
 def substitute_shutdown_on_path
+  Helper.instance.run_shell('puppet resource package which ensure=latest')
+  Helper.instance.run_shell('puppet resource package systemd-sysv ensure=latest') if os[:family] == 'debian' && os[:release].to_i == 9
   $shutdown_path = Helper.instance.run_shell('which shutdown').stdout.chomp
   if Helper.instance.run_shell("test -f #{SHUTDOWN_TEMP_LOC}", expect_failures: true).exit_code == 0
     return if Helper.instance.run_shell("sha1sum #{$shutdown_path} | cut -d ' ' -f 1").stdout.chomp == SHUTDOWN_SCRIPT_EXPECTED_SHA1

spec/unit/provider/reboot/linux_spec.rb

@@ -19,7 +19,7 @@
 
   context '#initialize' do
     it 'issues a deprecation warning' do
-      Puppet.expects(:deprecation_warning).with("The 'linux' reboot provider is deprecated and will be removed; use 'posix' instead.")
+      expect(Puppet).to receive(:deprecation_warning).with("The 'linux' reboot provider is deprecated and will be removed; use 'posix' instead.")
 
       Puppet::Type.type(:reboot).new(provider: :linux, name: 'linux_reboot')
     end
@@ -37,55 +37,55 @@
     end
 
     it 'does not reboot when setting the `when` property to refreshed' do
-      provider.expects(:reboot).never
+      expect(provider).to receive(:reboot).never
 
       provider.when = :refreshed
     end
   end
 
   context 'when a reboot is triggered', if: Puppet::Util.which('shutdown') do
     before :each do
-      provider.expects(:async_shutdown).with(includes('shutdown')).at_most_once
-      Facter.stubs(:value).with(:kernel).returns('Linux')
+      expect(provider).to receive(:async_shutdown).with(include('shutdown')).at_most(:once)
+      allow(Facter).to receive(:value).with(:kernel).and_return('Linux')
     end
 
     it 'stops the application by default' do
-      Puppet::Application.expects(:stop!)
+      expect(Puppet::Application).to receive(:stop!)
       provider.reboot
     end
 
     it 'cancels the rest of the catalog transaction if apply is set to immediately' do
       resource[:apply] = :immediately
-      Puppet::Application.expects(:stop!)
+      expect(Puppet::Application).to receive(:stop!)
       provider.reboot
     end
 
     it "doesn't stop the rest of the catalog transaction if apply is set to finished" do
       resource[:apply] = :finished
-      Puppet::Application.expects(:stop!).never
+      expect(Puppet::Application).to receive(:stop!).never
       provider.reboot
     end
 
     it 'includes the restart flag' do
-      provider.expects(:async_shutdown).with(includes('-r'))
+      expect(provider).to receive(:async_shutdown).with(include('-r')).at_most(:once)
       provider.reboot
     end
 
     it 'includes a timeout in the future' do
-      provider.expects(:async_shutdown).with(includes("+#{(resource[:timeout].to_i / 60.0).ceil}"))
+      expect(provider).to receive(:async_shutdown).with(include("+#{(resource[:timeout].to_i / 60.0).ceil}")).at_most(:once)
       provider.reboot
     end
 
     it 'rounds up and provides a warning if the timeout is not a multiple of 60' do
       resource[:timeout] = 61
-      Puppet.expects(:warning).with(includes('rounding'))
-      provider.expects(:async_shutdown).with(includes("+#{(resource[:timeout].to_i / 60.0).ceil}"))
+      expect(Puppet).to receive(:warning).with(include('rounding')).at_most(:once)
+      expect(provider).to receive(:async_shutdown).with(include("+#{(resource[:timeout].to_i / 60.0).ceil}")).at_most(:once)
       provider.reboot
     end
 
     it 'includes the quoted reboot message' do
       resource[:message] = 'triggering a reboot'
-      provider.expects(:async_shutdown).with(includes('"triggering a reboot"'))
+      expect(provider).to receive(:async_shutdown).with(include('"triggering a reboot"')).at_most(:once)
       provider.reboot
     end
   end

spec/unit/provider/reboot/posix_spec.rb

@@ -24,88 +24,88 @@
     end
 
     it 'does not reboot when setting the `when` property to refreshed' do
-      provider.expects(:reboot).never
+      expect(provider).to receive(:reboot).never
 
       provider.when = :refreshed
     end
   end
 
   context 'when a reboot is triggered', if: Puppet::Util.which('shutdown') do
     before :each do
-      provider.expects(:async_shutdown).with(includes('shutdown')).at_most_once
+      expect(provider).to receive(:async_shutdown).with(include('shutdown')).at_most(:once)
     end
 
     it 'stops the application by default' do
-      Puppet::Application.expects(:stop!)
+      expect(Puppet::Application).to receive(:stop!)
       provider.reboot
     end
 
     it 'cancels the rest of the catalog transaction if apply is set to immediately' do
       resource[:apply] = :immediately
-      Puppet::Application.expects(:stop!)
+      expect(Puppet::Application).to receive(:stop!)
       provider.reboot
     end
 
     it "doesn't stop the rest of the catalog transaction if apply is set to finished" do
       resource[:apply] = :finished
-      Puppet::Application.expects(:stop!).never
+      expect(Puppet::Application).to receive(:stop!).never
       provider.reboot
     end
 
     context 'on Solaris' do
       before :each do
-        Facter.stubs(:value).with(:kernel).returns('SunOS')
+        allow(Facter).to receive(:value).with(:kernel).and_return('SunOS')
       end
 
       it 'includes the pre-confirmation flag' do
-        provider.expects(:async_shutdown).with(includes('-y'))
+        expect(provider).to receive(:async_shutdown).with(include('-y')).at_most(:once)
         provider.reboot
       end
 
       it 'includes the init-state 6 flag' do
-        provider.expects(:async_shutdown).with(includes('-i 6'))
+        expect(provider).to receive(:async_shutdown).with(include('-i 6')).at_most(:once)
         provider.reboot
       end
 
       it 'includes a timeout in the future' do
-        provider.expects(:async_shutdown).with(includes("-g #{resource[:timeout].to_i}"))
+        expect(provider).to receive(:async_shutdown).with(include("-g #{resource[:timeout].to_i}")).at_most(:once)
         provider.reboot
       end
 
       it 'accepts timeouts that are not multiples of 60' do
         resource[:timeout] = 61
-        Puppet.expects(:warning).with(includes('rounding')).never
-        provider.expects(:async_shutdown).with(includes("-g #{resource[:timeout].to_i}"))
+        expect(Puppet).to receive(:warning).with(include('rounding')).never
+        expect(provider).to receive(:async_shutdown).with(include("-g #{resource[:timeout].to_i}")).at_most(:once)
         provider.reboot
       end
     end
 
     context 'on other systems' do
       before :each do
-        Facter.stubs(:value).with(:kernel).returns('Linux')
+        allow(Facter).to receive(:value).with(:kernel).and_return('Linux')
       end
 
       it 'includes the restart flag' do
-        provider.expects(:async_shutdown).with(includes('-r'))
+        expect(provider).to receive(:async_shutdown).with(include('-r')).at_most(:once)
         provider.reboot
       end
 
       it 'includes a timeout in the future' do
-        provider.expects(:async_shutdown).with(includes("+#{(resource[:timeout].to_i / 60.0).ceil}"))
+        expect(provider).to receive(:async_shutdown).with(include("+#{(resource[:timeout].to_i / 60.0).ceil}")).at_most(:once)
         provider.reboot
       end
 
       it 'rounds up and provides a warning if the timeout is not a multiple of 60' do
         resource[:timeout] = 61
-        Puppet.expects(:warning).with(includes('rounding'))
-        provider.expects(:async_shutdown).with(includes("+#{(resource[:timeout].to_i / 60.0).ceil}"))
+        expect(Puppet).to receive(:warning).with(include('rounding')).at_most(:once)
+        expect(provider).to receive(:async_shutdown).with(include("+#{(resource[:timeout].to_i / 60.0).ceil}")).at_most(:once)
         provider.reboot
       end
     end
 
     it 'includes the quoted reboot message' do
       resource[:message] = 'triggering a reboot'
-      provider.expects(:async_shutdown).with(includes('"triggering a reboot"'))
+      expect(provider).to receive(:async_shutdown).with(include('"triggering a reboot"')).at_most(:once)
       provider.reboot
     end
   end

spec/unit/task/init_spec.rb

@@ -1,19 +1,22 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require_relative '../../../tasks/init'
+# require_relative '../../../tasks/init'
+require File.dirname(__FILE__) + '/../../../tasks/init.rb'
 
 describe Reboot::Task do # rubocop:disable RSpec/FilePath
   context 'on Windows' do
-    before(:each) { Facter.stubs(:value).with(:kernel).returns('windows') }
+    before(:each) do
+      allow(Facter).to receive(:value).with(:kernel).and_return('windows')
+    end
 
     context 'when rebooting' do
       let(:reboot) { described_class.new }
 
       it 'runs the correct command' do
         command = 'shutdown.exe /r /t 3 /d p:4:1 '
-        reboot.expects(:shutdown_executable_windows).returns('shutdown.exe')
-        reboot.expects(:async_command).with(command).returns(nil)
+        expect(reboot).to receive(:shutdown_executable_windows).and_return('shutdown.exe')
+        expect(reboot).to receive(:async_command).with(command).and_return(nil)
         reboot.execute!
       end
 
@@ -22,16 +25,16 @@
 
         it 'handles the timeout' do
           command = 'shutdown.exe /r /t 20 /d p:4:1 '
-          reboot.expects(:shutdown_executable_windows).returns('shutdown.exe')
-          reboot.expects(:async_command).with(command).returns(nil)
+          expect(reboot).to receive(:shutdown_executable_windows).and_return('shutdown.exe')
+          expect(reboot).to receive(:async_command).with(command).and_return(nil)
           reboot.execute!
         end
 
         it 'does not allow timeouts < 3' do
           reboot = described_class.new('timeout' => 0)
           command = 'shutdown.exe /r /t 3 /d p:4:1 '
-          reboot.expects(:shutdown_executable_windows).returns('shutdown.exe')
-          reboot.expects(:async_command).with(command).returns(nil)
+          expect(reboot).to receive(:shutdown_executable_windows).and_return('shutdown.exe')
+          expect(reboot).to receive(:async_command).with(command).and_return(nil)
           reboot.execute!
         end
       end
@@ -42,23 +45,23 @@
 
       it 'runs the correct command' do
         command = 'shutdown.exe /s /t 3 /d p:4:1 '
-        reboot.expects(:shutdown_executable_windows).returns('shutdown.exe')
-        reboot.expects(:async_command).with(command).returns(nil)
+        expect(reboot).to receive(:shutdown_executable_windows).and_return('shutdown.exe')
+        expect(reboot).to receive(:async_command).with(command).and_return(nil)
         reboot.execute!
       end
     end
   end
 
   context 'on Solaris' do
-    before(:each) { Facter.stubs(:value).with(:kernel).returns('SunOS') }
+    before(:each) { allow(Facter).to receive(:value).with(:kernel).and_return('SunOS') }
 
     context 'when rebooting' do
       let(:reboot) { described_class.new }
 
       it 'runs the correct command' do
         # Enforces minimum 3s timeout.
         command = ['shutdown', '-y', '-i', '6', '-g', 3, "''", '</dev/null', '>/dev/null', '2>&1', '&']
-        reboot.expects(:async_command).with(command).returns(nil)
+        expect(reboot).to receive(:async_command).with(command).and_return(nil)
         reboot.execute!
       end
 
@@ -67,7 +70,7 @@
 
         it 'handles the timeout' do
           command = ['shutdown', '-y', '-i', '6', '-g', 20, "''", '</dev/null', '>/dev/null', '2>&1', '&']
-          reboot.expects(:async_command).with(command).returns(nil)
+          expect(reboot).to receive(:async_command).with(command).and_return(nil)
           reboot.execute!
         end
       end
@@ -79,22 +82,22 @@
       it 'runs the correct command' do
         # Enforces minimum 3s timeout.
         command = ['shutdown', '-y', '-i', '5', '-g', 3, "''", '</dev/null', '>/dev/null', '2>&1', '&']
-        reboot.expects(:async_command).with(command).returns(nil)
+        expect(reboot).to receive(:async_command).with(command).and_return(nil)
         reboot.execute!
       end
     end
   end
 
   context 'on Linux' do
-    before(:each) { Facter.stubs(:value).with(:kernel).returns('Linux') }
+    before(:each) { allow(Facter).to receive(:value).with(:kernel).and_return('Linux') }
 
     context 'when rebooting' do
       let(:reboot) { described_class.new }
 
       it 'runs the correct command' do
         command = ['shutdown', '-r', 'now', "''", '</dev/null', '>/dev/null', '2>&1', '&']
         # Enforces minimum 3s timeout.
-        reboot.expects(:async_command).with(command, 3).returns(nil)
+        expect(reboot).to receive(:async_command).with(command, 3).and_return(nil)
         reboot.execute!
       end
 
@@ -103,7 +106,7 @@
 
         it 'handles the timeout by sleeping' do
           command = ['shutdown', '-r', 'now', "''", '</dev/null', '>/dev/null', '2>&1', '&']
-          reboot.expects(:async_command).with(command, 20).returns(nil)
+          expect(reboot).to receive(:async_command).with(command, 20).and_return(nil)
           reboot.execute!
         end
       end
@@ -113,7 +116,7 @@
 
         it 'handles the timeout by sleeping' do
           command = ['shutdown', '-r', '+1', "''", '</dev/null', '>/dev/null', '2>&1', '&']
-          reboot.expects(:async_command).with(command, 30).returns(nil)
+          expect(reboot).to receive(:async_command).with(command, 30).and_return(nil)
           reboot.execute!
         end
       end
@@ -125,7 +128,7 @@
       it 'runs the correct command' do
         # Enforces minimum 3s timeout.
         command = ['shutdown', '-P', 'now', "''", '</dev/null', '>/dev/null', '2>&1', '&']
-        reboot.expects(:async_command).with(command, 3).returns(nil)
+        expect(reboot).to receive(:async_command).with(command, 3).and_return(nil)
         reboot.execute!
       end
     end