puppet 6.13.0-x64-mingw32 → 6.18.0-x64-mingw32

data/spec/unit/provider/package/zypper_spec.rb

@@ -176,6 +176,19 @@ describe Puppet::Type.type(:package).provider(:zypper) do
       @provider.install
     end
 
+    it "should install the package with --no-gpg-checks" do
+      allow(@resource).to receive(:[]).with(:name).and_return("php5")
+      allow(@resource).to receive(:[]).with(:install_options).and_return(['--no-gpg-checks', {'-p' => '/vagrant/files/localrepo/'}])
+      allow(@resource).to receive(:should).with(:ensure).and_return("5.4.10-4.5.6")
+      allow(@resource).to receive(:allow_virtual?).and_return(false)
+      allow(@provider).to receive(:zypper_version).and_return("1.2.8")
+
+      expect(@provider).to receive(:zypper).with('--quiet', '--no-gpg-checks', :install,
+        '--auto-agree-with-licenses', '--no-confirm', '-p=/vagrant/files/localrepo/', 'php5-5.4.10-4.5.6')
+      expect(@provider).to receive(:query).and_return("php5 0 5.4.10 4.5.6 x86_64")
+      @provider.install
+    end
+
     it "should install package with hash install options" do
       allow(@resource).to receive(:[]).with(:name).and_return('vim')
       allow(@resource).to receive(:[]).with(:install_options).and_return([{ '--a' => 'foo', '--b' => '"quoted bar"' }])
@@ -226,4 +239,89 @@ describe Puppet::Type.type(:package).provider(:zypper) do
       @provider.uninstall
     end
   end
+
+  context 'when installing with VersionRange' do
+    let(:search_output) { File.read(my_fixture('zypper-search-uninstalled.out')) }
+
+    before(:each) do
+      allow(@resource).to receive(:[]).with(:name).and_return('vim')
+      allow(@resource).to receive(:allow_virtual?).and_return(false)
+      allow(@provider).to receive(:zypper_version).and_return('1.0.2')
+
+      expect(@provider).to receive(:zypper).with('search', '--match-exact', '--type', 'package', '--uninstalled-only', '-s', 'vim')
+                                           .and_return(search_output)
+    end
+
+    it 'does install the package if version is available' do
+      expect(@resource).to receive(:should).with(:ensure).and_return('>1.0')
+
+      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'vim-1.0.20040813-19.9')
+      expect(@provider).to receive(:query).and_return('vim 0 1.0.20040813 19.9 x86_64')
+
+      @provider.install
+    end
+
+    it 'does consider range as version if version in range is not available' do
+      allow(@resource).to receive(:should).with(:ensure).and_return('>2.0')
+
+      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'vim->2.0')
+                             .and_raise(Puppet::ExecutionFailure.new('My Error'))
+
+      expect { @provider.install }.to raise_error(Puppet::ExecutionFailure, 'My Error')
+    end
+  end
+
+  describe 'insync?' do
+    subject { @provider.insync?('1.19-2') }
+
+    context 'when versions are matching' do
+      before { allow(@resource).to receive(:[]).with(:ensure).and_return('1.19-2') }
+
+      it { is_expected.to be true }
+    end
+
+    context 'when version are not matching' do
+      before { allow(@resource).to receive(:[]).with(:ensure).and_return('1.19-3') }
+
+      it { is_expected.to be false }
+    end
+
+    context 'when version is in gt range' do
+      before { allow(@resource).to receive(:[]).with(:ensure).and_return('>1.19-0') }
+
+      it { is_expected.to be true }
+    end
+
+    context 'when version is not in gt range' do
+      before { allow(@resource).to receive(:[]).with(:ensure).and_return('>1.19-2') }
+
+      it { is_expected.to be false }
+    end
+
+    context 'when version is in min-max range' do
+      before { allow(@resource).to receive(:[]).with(:ensure).and_return('>1.19-0 <1.19-3') }
+
+      it { is_expected.to be true }
+    end
+
+    context 'when version is not in min-max range' do
+      before { allow(@resource).to receive(:[]).with(:ensure).and_return('>1.19-0 <1.19-2') }
+
+      it { is_expected.to be false }
+    end
+
+    context 'when using eq range' do
+      context 'when ensure without release' do
+        before { allow(@resource).to receive(:[]).with(:ensure).and_return('1.19') }
+
+        it { is_expected.to be true }
+      end
+
+      context 'when ensure with release' do
+        before { allow(@resource).to receive(:[]).with(:ensure).and_return('1.19-2') }
+
+        it { is_expected.to be true }
+      end
+    end
+  end
 end

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

@@ -38,6 +38,47 @@ describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform
     %w{functions.sh reboot.sh shutdown.sh functions halt killall single linuxconf reboot boot wait-for-state rcS module-init-tools}
   end
 
+  describe "when running on FreeBSD" do
+    before :each do
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('FreeBSD')
+      allow(Facter).to receive(:value).with(:osfamily).and_return('FreeBSD')
+    end
+
+    it "should set its default path to include /etc/rc.d and /usr/local/etc/rc.d" do
+      expect(provider_class.defpath).to eq(["/etc/rc.d", "/usr/local/etc/rc.d"])
+    end
+  end
+
+  describe "when running on HP-UX" do
+    before :each do
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('HP-UX')
+    end
+
+    it "should set its default path to include /sbin/init.d" do
+      expect(provider_class.defpath).to eq("/sbin/init.d")
+    end
+  end
+
+  describe "when running on Archlinux" do
+    before :each do
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('Archlinux')
+    end
+
+    it "should set its default path to include /etc/rc.d" do
+      expect(provider_class.defpath).to eq("/etc/rc.d")
+    end
+  end
+
+  describe "when not running on FreeBSD, HP-UX or Archlinux" do
+    before :each do
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('RedHat')
+    end
+
+    it "should set its default path to include /etc/init.d" do
+      expect(provider_class.defpath).to eq("/etc/init.d")
+    end
+  end
+
   describe "when getting all service instances" do
     before :each do
       allow(provider_class).to receive(:defpath).and_return('tmp')
@@ -150,6 +191,7 @@ describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform
 
   describe "if the init script is present" do
     before :each do
+      allow(File).to receive(:directory?).and_call_original
       allow(File).to receive(:directory?).with("/service/path").and_return(true)
       allow(File).to receive(:directory?).with("/alt/service/path").and_return(true)
       allow(Puppet::FileSystem).to receive(:exist?).with("/service/path/myservice").and_return(true)

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

@@ -12,6 +12,15 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
     allow(FileTest).to receive(:executable?).with('/usr/sbin/rcctl').and_return(true)
   end
 
+  # `execute` and `texecute` start a new process, consequently setting $CHILD_STATUS to a Process::Status instance,
+  # but because they are mocked, an external process is never executed and $CHILD_STATUS remain nil.
+  # In order to execute some parts of the code under test and to mock $CHILD_STATUS, we need this variable to be a
+  # Process::Status instance. We can achieve this by starting a process that does nothing (exit 0). By doing this,
+  # $CHILD_STATUS will be initialised with a instance of Process::Status and we will be able to mock it.
+  before(:all) do
+    `exit 0`
+  end
+
   context "#instances" do
     it "should have an instances method" do
       expect(provider_class).to respond_to :instances

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

@@ -28,6 +28,7 @@ describe 'Puppet::Type::Service::Provider::Openwrt',
     allow(FileTest).to receive(:executable?).with('/etc/rc.common').and_return(true)
 
     # All OpenWrt tests operate on the init script directly. It must exist.
+    allow(File).to receive(:directory?).and_call_original
     allow(File).to receive(:directory?).with('/etc/init.d').and_return(true)
 
     allow(Puppet::FileSystem).to receive(:exist?).with('/etc/init.d/myservice').and_return(true)

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

@@ -4,6 +4,15 @@ describe 'Puppet::Type::Service::Provider::Redhat',
          if: Puppet.features.posix? && !Puppet::Util::Platform.jruby?do
   let(:provider_class) { Puppet::Type.type(:service).provider(:redhat) }
 
+  # `execute` and `texecute` start a new process, consequently setting $CHILD_STATUS to a Process::Status instance,
+  # but because they are mocked, an external process is never executed and $CHILD_STATUS remain nil.
+  # In order to execute some parts of the code under test and to mock $CHILD_STATUS, we need this variable to be a
+  # Process::Status instance. We can achieve this by starting a process that does nothing (exit 0). By doing this,
+  # $CHILD_STATUS will be initialised with a instance of Process::Status and we will be able to mock it.
+  before(:all) do
+    `exit 0`
+  end
+
   before :each do
     @class = Puppet::Type.type(:service).provider(:redhat)
     @resource = double('resource')

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

@@ -1,18 +1,22 @@
 require 'spec_helper'
 
-describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platform.jruby? do
+describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platform.jruby? || Puppet::Util::Platform.windows? 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\""
-    Puppet::Util::Execution.execute(command, {:failonfail => false})
-  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')
   end
 
+  # `execute` and `texecute` start a new process, consequently setting $CHILD_STATUS to a Process::Status instance,
+  # but because they are mocked, an external process is never executed and $CHILD_STATUS remain nil.
+  # In order to execute some parts of the code under test and to mock $CHILD_STATUS, we need this variable to be a
+  # Process::Status instance. We can achieve this by starting a process that does nothing (exit 0). By doing this,
+  # $CHILD_STATUS will be initialised with a instance of Process::Status and we will be able to mock it.
+  before(:all) do
+    `exit 0`
+  end
+
   let :provider do
     provider_class.new(:name => 'sshd.service')
   end
@@ -187,8 +191,18 @@ describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platf
         autovt@.service
         avahi-daemon.service
         blk-availability.service
+        apparmor.service
+        umountnfs.service
+        urandom.service
+        brandbot.service
       })
     end
+
+    it "should print a debug message when a service with the state `bad` is found" 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')))
+      expect(Puppet).to receive(:debug).with("apparmor.service marked as bad by `systemctl`. It is recommended to be further checked.")
+      provider_class.instances
+    end
   end
 
   describe "#start" do
@@ -269,43 +283,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 = 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)
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled', '--', 'sshd.service'], :failonfail => false).
+                            and_return(Puppet::Util::Execution::ProcessOutput.new("enabled\n", 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)
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled','--', 'sshd.service'], :failonfail => false).
+                            and_return(Puppet::Util::Execution::ProcessOutput.new("static\n", 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)
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled', '--', 'sshd.service'], :failonfail => false).
+                            and_return(Puppet::Util::Execution::ProcessOutput.new("disabled\n", 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)
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled', '--', 'sshd.service'], :failonfail => false).
+                            and_return(Puppet::Util::Execution::ProcessOutput.new("indirect\n", 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)
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled', '--', 'sshd.service'], :failonfail => false).
+                            and_return(Puppet::Util::Execution::ProcessOutput.new("masked\n", 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)
+      expect(provider).to receive(:execute).with(['/bin/systemctl','is-enabled', '--', 'sshd.service'], :failonfail => false).
+                            and_return(Puppet::Util::Execution::ProcessOutput.new("masked\n", 1))
       expect(provider.enabled?).to eq(:mask)
     end
   end
@@ -428,6 +442,67 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
     end
   end
 
+  describe "#insync_enabled?" do
+    let(:provider) do
+      provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => false))
+    end
+
+    before do
+      allow(provider).to receive(:cached_enabled?).and_return({ output: service_state, exitcode: 0 })
+    end
+
+    context 'when service state is static' do
+      let(:service_state) { 'static' }
+
+      it 'is always enabled_insync even if current value is the same as expected' do
+        expect(provider).to be_enabled_insync(:false)
+      end
+
+      it 'is always enabled_insync even if current value is not the same as expected' do
+        expect(provider).to be_enabled_insync(:true)
+      end
+
+      it 'logs a debug messsage' do
+        expect(Puppet).to receive(:debug).with("Unable to enable or disable static service sshd.service")
+        provider.enabled_insync?(:true)
+      end
+    end
+
+    context 'when service state is indirect' do
+      let(:service_state) { 'indirect' }
+
+      it 'is always enabled_insync even if current value is the same as expected' do
+        expect(provider).to be_enabled_insync(:false)
+      end
+
+      it 'is always enabled_insync even if current value is not the same as expected' do
+        expect(provider).to be_enabled_insync(:true)
+      end
+
+      it 'logs a debug messsage' do
+        expect(Puppet).to receive(:debug).with("Service sshd.service is in 'indirect' state and cannot be enabled/disabled")
+        provider.enabled_insync?(:true)
+      end
+    end
+
+    context 'when service state is enabled' do
+      let(:service_state) { 'enabled' }
+
+      it 'is enabled_insync if current value is the same as expected' do
+        expect(provider).to be_enabled_insync(:false)
+      end
+
+      it 'is not enabled_insync if current value is not the same as expected' do
+        expect(provider).not_to be_enabled_insync(:true)
+      end
+
+      it 'logs no debug messsage' do
+        expect(Puppet).not_to receive(:debug)
+        provider.enabled_insync?(:true)
+      end
+    end
+  end
+
   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'))

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

@@ -58,7 +58,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
       it "should enable if managing enable and enable is true" do
         resource[:enable] = :true
         expect(service_util).to receive(:start)
-        expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START)
+        expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_AUTO_START})
 
         provider.start
       end
@@ -66,7 +66,7 @@ describe 'Puppet::Type::Service::Provider::Windows',
       it "should manual start if managing enable and enable is false" do
         resource[:enable] = :false
         expect(service_util).to receive(:start)
-        expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
+        expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_DEMAND_START})
 
         provider.start
       end
@@ -88,6 +88,14 @@ describe 'Puppet::Type::Service::Provider::Windows',
       expect(provider.status).to eql(:stopped)
     end
 
+    it "should report service as stopped when status cannot be retrieved" do
+      allow(service_util).to receive(:exists?).with(resource[:name]).and_return(true)
+      allow(service_util).to receive(:service_state).with(name).and_raise(Puppet::Error.new('Service query failed: The specified path is invalid.'))
+
+      expect(Puppet).to receive(:warning).with("Status for service #{resource[:name]} could not be retrieved: Service query failed: The specified path is invalid.")
+      expect(provider.status).to eql(:stopped)
+    end
+
     [
       :SERVICE_PAUSED,
       :SERVICE_PAUSE_PENDING
@@ -119,6 +127,34 @@ describe 'Puppet::Type::Service::Provider::Windows',
         expect(provider.status).to eq(:running)
       end
     end
+
+    context 'when querying lmhosts', if: Puppet::Util::Platform.windows? do
+      # This service should be ubiquitous across all supported Windows platforms
+      let(:service) { Puppet::Type.type(:service).new(:name => 'lmhosts') }
+
+      before :each do
+        allow(service_util).to receive(:exists?).with(service.name).and_call_original
+      end
+
+      it "reports if the service is enabled" do
+        expect([:true, :false, :manual]).to include(service.provider.enabled?)
+      end
+
+      it "reports on the service status" do
+        expect(
+          [
+            :running,
+            :'continue pending',
+            :'pause pending',
+            :paused,
+            :running,
+            :'start pending',
+            :'stop pending',
+            :stopped
+          ]
+        ).to include(service.provider.status)
+      end
+    end
   end
 
   describe "#restart" do
@@ -178,12 +214,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#enable" do
     it "should set service start type to Service_Auto_Start when enabled" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START)
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_AUTO_START})
       provider.enable
     end
 
-    it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START).and_raise(Puppet::Error.new('foobar'))
+    it "raises an error if set_startup_configuration fails" do
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_AUTO_START}).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.enable
@@ -193,12 +229,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#disable" do
     it "should set service start type to Service_Disabled when disabled" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DISABLED)
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_DISABLED})
       provider.disable
     end
 
-    it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DISABLED).and_raise(Puppet::Error.new('foobar'))
+    it "raises an error if set_startup_configuration fails" do
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_DISABLED}).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.disable
@@ -208,12 +244,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#manual_start" do
     it "should set service start type to Service_Demand_Start (manual) when manual" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_DEMAND_START})
       provider.manual_start
     end
 
-    it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_DEMAND_START).and_raise(Puppet::Error.new('foobar'))
+    it "raises an error if set_startup_configuration fails" do
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_DEMAND_START}).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.manual_start
@@ -223,12 +259,12 @@ describe 'Puppet::Type::Service::Provider::Windows',
 
   describe "#delayed_start" do
     it "should set service start type to Service_Config_Delayed_Auto_Start (delayed) when delayed" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START, true)
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_AUTO_START, delayed: true})
       provider.delayed_start
     end
 
-    it "raises an error if set_startup_mode fails" do
-      expect(service_util).to receive(:set_startup_mode).with(name, :SERVICE_AUTO_START, true).and_raise(Puppet::Error.new('foobar'))
+    it "raises an error if set_startup_configuration fails" do
+      expect(service_util).to receive(:set_startup_configuration).with(name, options: {startup_type: :SERVICE_AUTO_START, delayed: true}).and_raise(Puppet::Error.new('foobar'))
 
       expect {
         provider.delayed_start