puppet 5.5.14 → 5.5.16

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

@@ -33,40 +33,56 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
     end
 
     it "should use the path to the gem command" do
-      allow(described_class).to receive(:which).with(provider_gem_cmd).and_return(provider_gem_cmd)
+      allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
       expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return('')
       provider.install
     end
 
     it "should not append install_options by default" do
-      expect(described_class).to receive(:execute_gem_command).with(%w{install --no-rdoc --no-ri myresource}).and_return('')
+      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{install --no-rdoc --no-ri myresource}).and_return('')
       provider.install
     end
 
     it "should allow setting an install_options parameter" do
       resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      expect(described_class).to receive(:execute_gem_command).with(%w{install --force --bindir=/usr/bin --no-rdoc --no-ri myresource}).and_return('')
+      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{install --force --bindir=/usr/bin --no-rdoc --no-ri myresource}).and_return('')
       provider.install
     end
   end
 
   context "when uninstalling" do
     it "should use the path to the gem command" do
-      allow(described_class).to receive(:which).with(provider_gem_cmd).and_return(provider_gem_cmd)
+      allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
       expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return('')
       provider.uninstall
     end
 
     it "should not append uninstall_options by default" do
-      expect(described_class).to receive(:execute_gem_command).with(%w{uninstall --executables --all myresource}).and_return('')
+      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource}).and_return('')
       provider.uninstall
     end
 
     it "should allow setting an uninstall_options parameter" do
       resource[:uninstall_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      expect(described_class).to receive(:execute_gem_command).with(%w{uninstall --executables --all myresource --force --bindir=/usr/bin}).and_return('')
+      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource --force --bindir=/usr/bin}).and_return('')
       provider.uninstall
     end
   end
 
+  context 'calculated specificity' do
+    context 'when is not defaultfor' do
+      subject { described_class.specificity }
+      it { is_expected.to eql 1 }
+    end
+
+    context 'when is defaultfor' do
+      let(:os) {  Facter.value(:operatingsystem) }
+      subject do
+        described_class.defaultfor(operatingsystem: os)
+        described_class.specificity
+      end
+      it { is_expected.to be > 100 }
+    end
+  end
+
 end

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

@@ -56,7 +56,9 @@ describe Puppet::Type.type(:package).provider(:rpm) do
   describe "self.instances" do
     describe "with a modern version of RPM" do
       it "includes all the modern flags" do
-        expect(Puppet::Util::Execution).to receive(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'").and_yield(packages)
+        expect(Puppet::Util::Execution).to receive(:execpipe)
+          .with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'")
+          .and_yield(packages)
 
         described_class.instances
       end
@@ -66,7 +68,9 @@ describe Puppet::Type.type(:package).provider(:rpm) do
       let(:rpm_version) { "RPM version 4.0.2\n" }
 
       it "excludes the --nosignature flag" do
-        expect(Puppet::Util::Execution).to receive(:execpipe).with("/bin/rpm -qa  --nodigest --qf '#{nevra_format}'").and_yield(packages)
+        expect(Puppet::Util::Execution).to receive(:execpipe)
+          .with("/bin/rpm -qa  --nodigest --qf '#{nevra_format}'")
+          .and_yield(packages)
 
         described_class.instances
       end
@@ -76,14 +80,18 @@ describe Puppet::Type.type(:package).provider(:rpm) do
       let(:rpm_version) { "RPM version 3.0.5\n" }
 
       it "excludes the --nodigest flag" do
-        expect(Puppet::Util::Execution).to receive(:execpipe).with("/bin/rpm -qa   --qf '#{nevra_format}'").and_yield(packages)
+        expect(Puppet::Util::Execution).to receive(:execpipe)
+        .with("/bin/rpm -qa   --qf '#{nevra_format}'")
+        .and_yield(packages)
 
         described_class.instances
       end
     end
 
     it "returns an array of packages" do
-      expect(Puppet::Util::Execution).to receive(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'").and_yield(packages)
+      expect(Puppet::Util::Execution).to receive(:execpipe)
+        .with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'")
+        .and_yield(packages)
 
       installed_packages = described_class.instances
 
@@ -167,7 +175,8 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
     describe "when not already installed" do
       it "only includes the '-i' flag" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", ["-i"], '/path/to/package'], execute_options)
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", ["-i"], '/path/to/package'], execute_options)
         provider.install
       end
     end
@@ -184,7 +193,8 @@ describe Puppet::Type.type(:package).provider(:rpm) do
       end
 
       it "includes the options" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", ["-i", "-D", "--test=value", "-Q"], '/path/to/package'], execute_options)
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", ["-i", "-D", "--test=value", "-Q"], '/path/to/package'], execute_options)
         provider.install
       end
     end
@@ -197,7 +207,8 @@ describe Puppet::Type.type(:package).provider(:rpm) do
       end
 
       it "includes the '-U --oldpackage' flags" do
-         expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", ["-U", "--oldpackage"], '/path/to/package'], execute_options)
+         expect(Puppet::Util::Execution).to receive(:execute)
+           .with(["/bin/rpm", ["-U", "--oldpackage"], '/path/to/package'], execute_options)
          provider.install
       end
     end
@@ -214,7 +225,9 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
     it "raises an error if the rpm command fails" do
       expect(resource).to receive(:[]).with(:source).and_return('source-string')
-      expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"]).and_raise(Puppet::ExecutionFailure, 'rpm command failed')
+      expect(Puppet::Util::Execution).to receive(:execute)
+        .with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"])
+        .and_raise(Puppet::ExecutionFailure, 'rpm command failed')
 
       expect {
         provider.latest
@@ -225,52 +238,115 @@ describe Puppet::Type.type(:package).provider(:rpm) do
   describe "#uninstall" do
     let(:resource) do
       Puppet::Type.type(:package).new(
-        :name     => 'myresource',
-        :ensure   => :installed
+        :name   => resource_name,
+        :ensure => :installed
       )
     end
 
+    describe "on an ancient RPM" do
+      let(:rpm_version) { "RPM version 3.0.6\n" }
+
+      before(:each) do
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", "-q", resource_name, '', '', '--qf', "'#{nevra_format}'"], execute_options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
+      end
+
+      it "excludes the architecture from the package name" do
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", ["-e"], resource_name], execute_options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
+        provider.uninstall
+      end
+    end
+
     describe "on a modern RPM" do
+      let(:rpm_version) { "RPM version 4.10.0\n" }
+
+
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+          .with(["/bin/rpm", "-q", resource_name, '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
       end
 
+      it "excludes the architecture from the package name" do
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", ["-e"], resource_name], execute_options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
+        provider.uninstall
+      end
+    end
+
+    describe "on a modern RPM when architecture is specified" do
       let(:rpm_version) { "RPM version 4.10.0\n" }
 
+      let(:resource) do
+        Puppet::Type.type(:package).new(
+          :name   => "#{resource_name}.noarch",
+          :ensure => :absent,
+        )
+      end
+
+      before(:each) do
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", "-q", "#{resource_name}.noarch", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
+      end
+
       it "includes the architecture in the package name" do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options)
+          .with(["/bin/rpm", ["-e"], "#{resource_name}.noarch"], execute_options)
           .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
         provider.uninstall
       end
     end
 
-    describe "on an ancient RPM" do
+    describe "when version and release are specified" do
+      let(:resource) do
+        Puppet::Type.type(:package).new(
+          :name   => "#{resource_name}-1.2.3.4-5.el4",
+          :ensure => :absent,
+        )
+      end
+
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "myresource", '', '', '--qf', "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+          .with(["/bin/rpm", "-q", "#{resource_name}-1.2.3.4-5.el4", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
       end
 
-      let(:rpm_version) { "RPM version 3.0.6\n" }
-
-      it "excludes the architecture from the package name" do
+      it "includes the version and release in the package name" do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4'], execute_options)
+          .with(["/bin/rpm", ["-e"], "#{resource_name}-1.2.3.4-5.el4"], execute_options)
           .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
         provider.uninstall
       end
     end
 
-    describe "when uninstalled with options" do
+    describe "when only version is specified" do
+      let(:resource) do
+        Puppet::Type.type(:package).new(
+          :name   => "#{resource_name}-1.2.3.4",
+          :ensure => :absent,
+        )
+      end
+
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+          .with(["/bin/rpm", "-q", "#{resource_name}-1.2.3.4", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
       end
 
+      it "includes the version in the package name" do
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", ["-e"], "#{resource_name}-1.2.3.4"], execute_options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
+        provider.uninstall
+      end
+    end
+
+    describe "when uninstalled with options" do
       let(:resource) do
         Puppet::Type.type(:package).new(
           :name              => resource_name,
@@ -280,8 +356,15 @@ describe Puppet::Type.type(:package).provider(:rpm) do
         )
       end
 
+      before(:each) do
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", "-q", resource_name, '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
+      end
+
       it "includes the options" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", ["-e", "--nodeps"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options)
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", ["-e", "--nodeps"], resource_name], execute_options)
         provider.uninstall
       end
     end
@@ -331,7 +414,9 @@ describe Puppet::Type.type(:package).provider(:rpm) do
       before do
         expect(Puppet).not_to receive(:debug)
         expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"]
-        expect(Puppet::Util::Execution).to receive(:execute).with(expected_args, execute_options).and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not installed"))
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(expected_args, execute_options)
+          .and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not installed"))
       end
 
       it "does not log or fail if allow_virtual is false" do
@@ -342,7 +427,9 @@ describe Puppet::Type.type(:package).provider(:rpm) do
       it "does not log or fail if allow_virtual is true" do
         resource[:allow_virtual] = true
         expected_args = ['/bin/rpm', '-q', resource_name, '--nosignature', '--nodigest', '--qf', "'#{nevra_format}'", '--whatprovides']
-        expect(Puppet::Util::Execution).to receive(:execute).with(expected_args, execute_options).and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not provided"))
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(expected_args, execute_options)
+          .and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not provided"))
         expect(provider.query).to be_nil
       end
     end
@@ -350,7 +437,9 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     it "parses virtual package" do
       provider.resource[:allow_virtual] = true
       expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"]
-      expect(Puppet::Util::Execution).to receive(:execute).with(expected_args, execute_options).and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not installed"))
+      expect(Puppet::Util::Execution).to receive(:execute)
+        .with(expected_args, execute_options)
+        .and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not installed"))
       expect(Puppet::Util::Execution).to receive(:execute)
         .with(expected_args + ["--whatprovides"], execute_options)
         .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))

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

@@ -33,32 +33,16 @@ describe Puppet::Type.type(:service).provider(:upstart) do
   end
 
   context "upstart daemon existence confine" do
-    # We have a separate method here because our search for the upstart daemon
-    # confine expects it to be the last confine declared in the upstart provider.
-    # If in the future we add other confines below it or change its order, these
-    # unit tests will fail. Placing knowledge of where this confine is located
-    # in one place makes updating it less painful in case we ever need to do this.
-    def assert_upstart_daemon_existence_confine_is(expected_value)
-      upstart_daemon_existence_confine = provider_class.confine_collection.instance_variable_get(:@confines)[-1]
-      expect(upstart_daemon_existence_confine.valid?).to be(expected_value)
-    end
-
     let(:initctl_version) { ['/sbin/initctl', 'version', '--quiet'] }
 
     before(:each) do
-      # Stub out /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.
-      # Hence before each test, we want to reload the upstart provider so that the
-      # confine is re-evaluated.
-      Puppet::Type.type(:service).unprovide(:upstart)
     end
 
     it "should return true when the daemon is running" do
       expect(Puppet::Util::Execution).to receive(:execute).with(initctl_version, instance_of(Hash))
-      assert_upstart_daemon_existence_confine_is(true)
+
+      expect(provider_class).to be_has_initctl
     end
 
     it "should return false when the daemon is not running" do
@@ -66,7 +50,7 @@ describe Puppet::Type.type(:service).provider(:upstart) do
         .with(initctl_version, instance_of(Hash))
         .and_raise(Puppet::ExecutionFailure, "initctl failed!")
 
-      assert_upstart_daemon_existence_confine_is(false)
+      expect(provider_class).to_not be_has_initctl
     end
   end
 

data/spec/unit/settings/server_list_setting_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'puppet/settings/server_list_setting'
+
+describe Puppet::Settings::ServerListSetting do
+
+    it "prints strings as strings" do
+      settings = Puppet::Settings.new
+      settings.define_settings(:main, neptune: {type: :server_list, desc: 'list of servers'})
+      server_list_setting = settings.setting(:neptune)
+      expect(server_list_setting.print("jupiter,mars")).to eq("jupiter,mars")
+    end
+
+    it "prints arrays as strings" do
+      settings = Puppet::Settings.new
+      settings.define_settings(:main, neptune: {type: :server_list, desc: 'list of servers'})
+      server_list_setting = settings.setting(:neptune)
+      expect(server_list_setting.print([["main", 1234],["production", 8140]])).to eq("main:1234,production:8140")
+      expect(server_list_setting.print([])).to eq("")
+    end
+
+end

data/spec/unit/ssl/validator_spec.rb

@@ -186,6 +186,7 @@ describe Puppet::SSL::Validator::DefaultValidator do
       allow(subject).to receive(:ssl_certificates_are_present?).and_return(true)
       connection = double('Net::HTTP')
 
+      allow(connection).to receive(:address).and_return('puppet.com')
       expect(connection).to receive(:cert_store=).with(ssl_host.ssl_store)
       expect(connection).to receive(:ca_file=).with(ssl_configuration.ca_auth_file)
       expect(connection).to receive(:cert=).with(ssl_host.certificate.content)
@@ -200,6 +201,7 @@ describe Puppet::SSL::Validator::DefaultValidator do
       allow(subject).to receive(:ssl_certificates_are_present?).and_return(false)
       connection = double('Net::HTTP')
 
+      allow(connection).to receive(:address).and_return('puppet.com')
       expect(connection).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
 
       subject.setup_connection(connection)

data/spec/unit/util/pidlock_spec.rb

@@ -22,6 +22,23 @@ describe Puppet::Util::Pidlock do
 
     it "should become locked" do
       @lock.lock
+      if Puppet::Util::Platform.windows?
+        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
+      else
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('puppet')
+      end
+      expect(@lock).to be_locked
+    end
+
+    it "should become locked if puppet is a gem" do
+      @lock.lock
+      unless Puppet::Util::Platform.windows?
+        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
+        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
+      else
+        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\tools\ruby25\bin\ruby.exe')
+      end
       expect(@lock).to be_locked
     end
 
@@ -100,6 +117,23 @@ describe Puppet::Util::Pidlock do
   describe "#locked?" do
     it "should return true if locked" do
       @lock.lock
+      if Puppet::Util::Platform.windows?
+        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
+      else
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('puppet')
+      end
+      expect(@lock).to be_locked
+    end
+
+    it "should return true if locked when puppet as gem" do
+      @lock.lock
+      unless Puppet::Util::Platform.windows?
+        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
+        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
+      else
+        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\tools\ruby25\bin\ruby.exe')
+      end
       expect(@lock).to be_locked
     end
 
@@ -145,6 +179,12 @@ describe Puppet::Util::Pidlock do
       end
 
       it "should replace with new locks" do
+        if Puppet::Util::Platform.windows?
+          allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(6789).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
+        else
+          allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 6789, '-o', 'comm=']).and_return('puppet')
+          allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 6789, '-o', 'args=']).and_return('puppet')
+        end
         @lock.lock
         expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
         expect(@lock.lock_pid).to eq(6789)
@@ -169,6 +209,12 @@ describe Puppet::Util::Pidlock do
     before(:each) do
       # fake our pid to be 1234
       allow(Process).to receive(:pid).and_return(1234)
+      if Puppet::Util::Platform.windows?
+        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(1234).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
+      else
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'comm=']).and_return('puppet')
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'args=']).and_return('puppet')
+      end
       # lock the file
       @lock.lock
       # fake our pid to be a different pid, to simulate someone else