puppet 6.14.0 → 6.19.0

data/spec/unit/util/package/version/range_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+require 'puppet/util/package/version/range'
+
+class IntegerVersion
+  class ValidationFailure < ArgumentError; end
+  include Comparable
+  REGEX_FULL    = '(\d+)'.freeze
+  REGEX_FULL_RX = /\A#{REGEX_FULL}\Z/.freeze
+
+  def self.parse(ver)
+    match, version = *ver.match(REGEX_FULL_RX)
+    raise ValidationFailure, "Unable to parse '#{ver}' as a version identifier" unless match
+
+    new(version).freeze
+  end
+
+  attr_reader :version
+
+  def initialize(version)
+    @version = version.to_i
+  end
+
+  def <=>(other)
+    @version <=> other.version
+  end
+end
+
+describe Puppet::Util::Package::Version::Range do
+  context 'when creating new version range' do
+    it 'should raise unless String is passed' do
+      expect { Puppet::Util::Package::Version::Range.parse(:abc, IntegerVersion) }.to raise_error(Puppet::Util::Package::Version::Range::ValidationFailure)
+    end
+    it 'should raise if operator is not implemented' do
+      expect { Puppet::Util::Package::Version::Range.parse('=a', IntegerVersion) }.to raise_error(Puppet::Util::Package::Version::Range::ValidationFailure)
+    end
+    it 'should raise if operator cannot be parsed' do
+      expect { Puppet::Util::Package::Version::Range.parse('~=a', IntegerVersion) }.to raise_error(IntegerVersion::ValidationFailure)
+    end
+    it 'should raise if version cannot be parsed' do
+      expect { Puppet::Util::Package::Version::Range.parse('>=a', IntegerVersion) }.to raise_error(IntegerVersion::ValidationFailure)
+    end
+  end
+
+  context 'when creating new version range with regular version' do
+    it 'it does not include greater version' do
+      vr = Puppet::Util::Package::Version::Range.parse('3', IntegerVersion)
+      v = IntegerVersion.parse('4')
+      expect(vr.include?(v)).to eql(false)
+    end
+
+    it 'it includes specified version' do
+      vr = Puppet::Util::Package::Version::Range.parse('3', IntegerVersion)
+      v = IntegerVersion.parse('3')
+      expect(vr.include?(v)).to eql(true)
+    end
+
+    it 'it does not include lower version' do
+      vr = Puppet::Util::Package::Version::Range.parse('3', IntegerVersion)
+      v = IntegerVersion.parse('2')
+      expect(vr.include?(v)).to eql(false)
+    end
+  end
+
+  context 'when creating new version range with greater or equal operator' do
+    it 'it includes greater version' do
+      vr = Puppet::Util::Package::Version::Range.parse('>=3', IntegerVersion)
+      v = IntegerVersion.parse('4')
+      expect(vr.include?(v)).to eql(true)
+    end
+
+    it 'it includes specified version' do
+      vr = Puppet::Util::Package::Version::Range.parse('>=3', IntegerVersion)
+      v = IntegerVersion.parse('3')
+      expect(vr.include?(v)).to eql(true)
+    end
+
+    it 'it does not include lower version' do
+      vr = Puppet::Util::Package::Version::Range.parse('>=3', IntegerVersion)
+      v = IntegerVersion.parse('2')
+      expect(vr.include?(v)).to eql(false)
+    end
+  end
+
+  context 'when creating new version range with greater operator' do
+    it 'it includes greater version' do
+      vr = Puppet::Util::Package::Version::Range.parse('>3', IntegerVersion)
+      v = IntegerVersion.parse('10')
+      expect(vr.include?(v)).to eql(true)
+    end
+
+    it 'it does not include specified version' do
+      vr = Puppet::Util::Package::Version::Range.parse('>3', IntegerVersion)
+      v = IntegerVersion.parse('3')
+      expect(vr.include?(v)).to eql(false)
+    end
+
+    it 'it does not include lower version' do
+      vr = Puppet::Util::Package::Version::Range.parse('>3', IntegerVersion)
+      v = IntegerVersion.parse('1')
+      expect(vr.include?(v)).to eql(false)
+    end
+  end
+
+  context 'when creating new version range with lower or equal operator' do
+    it 'it does not include greater version' do
+      vr = Puppet::Util::Package::Version::Range.parse('<=3', IntegerVersion)
+      v = IntegerVersion.parse('5')
+      expect(vr.include?(v)).to eql(false)
+    end
+
+    it 'it includes specified version' do
+      vr = Puppet::Util::Package::Version::Range.parse('<=3', IntegerVersion)
+      v = IntegerVersion.parse('3')
+      expect(vr.include?(v)).to eql(true)
+    end
+
+    it 'it includes lower version' do
+      vr = Puppet::Util::Package::Version::Range.parse('<=3', IntegerVersion)
+      v = IntegerVersion.parse('1')
+      expect(vr.include?(v)).to eql(true)
+    end
+  end
+
+  context 'when creating new version range with lower operator' do
+    it 'it does not include greater version' do
+      vr = Puppet::Util::Package::Version::Range.parse('<3', IntegerVersion)
+      v = IntegerVersion.parse('8')
+      expect(vr.include?(v)).to eql(false)
+    end
+
+    it 'it does not include specified version' do
+      vr = Puppet::Util::Package::Version::Range.parse('<3', IntegerVersion)
+      v = IntegerVersion.parse('3')
+      expect(vr.include?(v)).to eql(false)
+    end
+
+    it 'it includes lower version' do
+      vr = Puppet::Util::Package::Version::Range.parse('<3', IntegerVersion)
+      v = IntegerVersion.parse('2')
+      expect(vr.include?(v)).to eql(true)
+    end
+  end
+
+  context 'when creating new version range with interval' do
+    it 'it does not include greater version' do
+      vr = Puppet::Util::Package::Version::Range.parse('>3 <=5', IntegerVersion)
+      v = IntegerVersion.parse('7')
+      expect(vr.include?(v)).to eql(false)
+    end
+
+    it 'it includes specified max interval value' do
+      vr = Puppet::Util::Package::Version::Range.parse('>3 <=5', IntegerVersion)
+      v = IntegerVersion.parse('5')
+      expect(vr.include?(v)).to eql(true)
+    end
+
+    it 'it includes in interval version' do
+      vr = Puppet::Util::Package::Version::Range.parse('>3 <=5', IntegerVersion)
+      v = IntegerVersion.parse('4')
+      expect(vr.include?(v)).to eql(true)
+    end
+
+    it 'it does not include min interval value ' do
+      vr = Puppet::Util::Package::Version::Range.parse('>3 <=5', IntegerVersion)
+      v = IntegerVersion.parse('3')
+      expect(vr.include?(v)).to eql(false)
+    end
+
+    it 'it does not include lower value ' do
+      vr = Puppet::Util::Package::Version::Range.parse('>3 <=5', IntegerVersion)
+      v = IntegerVersion.parse('2')
+      expect(vr.include?(v)).to eql(false)
+    end
+  end
+end

data/spec/unit/util/package/version/rpm_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'puppet/util/package/version/rpm'
+
+describe Puppet::Util::Package::Version::Rpm do
+
+  context "when parsing an invalid version" do
+    it "raises ArgumentError" do
+      expect { described_class.parse(:absent)}.to raise_error(ArgumentError)
+    end
+  end
+
+  context "when creating new version" do
+    it "is parsing basic version" do
+      v = described_class.parse('1:2.8.8-1.el6')
+      expect([v.epoch, v.version, v.release, v.arch ]).to eq(['1', '2.8.8', '1.el6' , nil])
+    end
+
+    it "is parsing no epoch basic version" do
+      v = described_class.parse('2.8.8-1.el6')
+      expect([v.epoch, v.version, v.release, v.arch ]).to eq([nil, '2.8.8', '1.el6', nil])
+    end
+
+    it "is parsing no epoch basic short version" do
+      v = described_class.parse('7.15-8.fc29')
+      expect([v.epoch, v.version, v.release, v.arch ]).to eq([nil, '7.15', '8.fc29', nil])
+    end
+
+    it "is parsing no epoch and no release basic version" do
+      v = described_class.parse('2.8.8')
+      expect([v.epoch, v.version, v.release, v.arch ]).to eq([nil, '2.8.8', nil, nil])
+    end
+
+    it "is parsing no epoch complex version" do
+      v = described_class.parse('1.4-0.24.20120830CVS.fc31')
+      expect([v.epoch, v.version, v.release, v.arch ]).to eq([nil, '1.4', '0.24.20120830CVS.fc31', nil])
+    end
+  end
+
+  context "when comparing two versions" do
+    context 'with invalid version' do
+      it 'raises ArgumentError' do
+        version = described_class.parse('0:1.5.3-3.el6')
+        invalid = 'invalid'
+        expect { version < invalid }.to \
+          raise_error(ArgumentError, 'Cannot compare, as invalid is not a Rpm Version')
+      end
+    end
+
+    context 'with valid versions' do
+      it "epoch has precedence" do
+        lower = described_class.parse('0:1.5.3-3.el6')
+        higher = described_class.parse('1:1.7.0-15.fc29')
+        expect(lower).to be < higher
+      end
+
+      it 'handles no epoch as 0 epoch' do
+        lower = described_class.parse('1.5.3-3.el6')
+        higher = described_class.parse('1:1.7.0-15.fc29')
+        expect(lower).to be < higher
+      end
+
+      it "handles equals letters-only versions" do
+        first = described_class.parse('abd-def')
+        second = described_class.parse('abd-def')
+        expect(first).to eq(second)
+      end
+
+      it "shorter version is smaller letters-only versions" do
+        lower = described_class.parse('ab')
+        higher = described_class.parse('abd')
+        expect(lower).to be < higher
+      end
+
+      it "shorter version is smaller even with digits" do
+        lower = described_class.parse('1.7')
+        higher = described_class.parse('1.7.0')
+        expect(lower).to be < higher
+      end
+
+      it "shorter version is smaller when number is less" do
+        lower = described_class.parse('1.7.0')
+        higher = described_class.parse('1.7.1')
+        expect(lower).to be < higher
+      end
+
+      it "shorter release is smaller " do
+        lower = described_class.parse('1.7.0-11.fc26')
+        higher = described_class.parse('1.7.0-11.fc27')
+        expect(lower).to be < higher
+      end
+
+      it "release letters are smaller letters-only" do
+        lower = described_class.parse('1.7.0-abc')
+        higher = described_class.parse('1.7.0-abd')
+        expect(lower).to be < higher
+      end
+
+      it "shorter release is smaller" do
+        lower = described_class.parse('1.7.0-11.fc2')
+        higher = described_class.parse('1.7.0-11.fc17')
+        expect(lower).to be < higher
+      end
+
+      it "handles equal release" do
+        first = described_class.parse('1.7.0-11.fc27')
+        second = described_class.parse('1.7.0-11.fc27')
+        expect(first).to eq(second)
+      end
+    end
+
+    context 'when one has no epoch' do
+      it 'handles no epoch as zero' do
+        version1 = described_class.parse('1:1.2')
+        version2 = described_class.parse('1.4')
+
+        expect(version1).to be > version2
+        expect(version2).to be < version1
+      end
+    end
+  end
+end

data/spec/unit/util/pidlock_spec.rb

@@ -13,21 +13,30 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
   end
 
   describe "#ps pid argument on posix", unless: Puppet::Util::Platform.windows? do
+    let(:other_pid) { Process.pid + 1 }
+
+    before do
+      # another process has locked the pidfile
+      File.write(@lockfile, other_pid)
+
+      # and it's still active
+      allow(Process).to receive(:kill).with(0, other_pid)
+    end
+
     it "should fallback to '-p' when ps execution fails with '-eq' on Linux" do
-      @lock.lock
-      allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', @lock.lock_pid, '-o', 'comm=']).and_raise(Puppet::ExecutionFailure, 'Execution of command returned 1: error')
+      allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', other_pid, '-o', 'comm=']).and_raise(Puppet::ExecutionFailure, 'Execution of command returned 1: error')
+
+      expect(Puppet::Util::Execution).to receive(:execute).with(['ps', "-p", other_pid, '-o', 'comm=']).and_return('puppet')
+      expect(Puppet::Util::Execution).to receive(:execute).with(['ps', "-p", other_pid, '-o', 'args=']).and_return('puppet')
 
-      expect(Puppet::Util::Execution).to receive(:execute).with(['ps', "-p", @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
-      expect(Puppet::Util::Execution).to receive(:execute).with(['ps', "-p", @lock.lock_pid, '-o', 'args=']).and_return('puppet')
       expect(@lock).to be_locked
     end
 
     shared_examples_for 'a valid ps argument was provided' do |desired_kernel, ps_argument|
       it "should be '#{ps_argument}' when current kernel is #{desired_kernel}" do
-        @lock.lock
         allow(Facter).to receive(:value).with(:kernel).and_return(desired_kernel)
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', ps_argument, @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', ps_argument, @lock.lock_pid, '-o', 'args=']).and_return('puppet')
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', ps_argument, other_pid, '-o', 'comm=']).and_return('ruby')
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', ps_argument, other_pid, '-o', 'args=']).and_return('puppet')
         expect(@lock).to be_locked
       end
     end
@@ -56,23 +65,6 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? 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', '-eq', @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', @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
-      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:\tools\ruby25\bin\ruby.exe')
-      else
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', @lock.lock_pid, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
-      end
       expect(@lock).to be_locked
     end
 
@@ -151,23 +143,6 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? 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', '-eq', @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', @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
-      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:\tools\ruby25\bin\ruby.exe')
-      else
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', @lock.lock_pid, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
-      end
       expect(@lock).to be_locked
     end
 
@@ -213,12 +188,6 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? 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', '-eq', 6789, '-o', 'comm=']).and_return('puppet')
-          allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', 6789, '-o', 'args=']).and_return('puppet')
-        end
         @lock.lock
         expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
         expect(@lock.lock_pid).to eq(6789)
@@ -239,6 +208,49 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
     end
   end
 
+  describe "with no access to open the process on Windows", :if => Puppet.features.microsoft_windows? do
+    before(:each) do
+      allow(Process).to receive(:pid).and_return(6789)
+      @lock.lock
+      allow(Process).to receive(:pid).and_return(1234)
+      exception = Puppet::Util::Windows::Error.new('Access Denied', 5) # ERROR_ACCESS_DENIED
+      allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(6789).and_raise(exception)
+      allow(Process).to receive(:kill).with(0, 6789)
+      allow(Process).to receive(:kill).with(0, 1234)
+    end
+
+    it "should be locked" do
+      expect(@lock).to be_locked
+    end
+
+    describe "#lock" do
+      it "should not be possible" do
+        expect(@lock.lock).to be_falsey
+      end
+
+      it "should not overwrite the lock" do
+        @lock.lock
+        expect(@lock).not_to be_mine
+      end
+    end
+
+    describe "#unlock" do
+      it "should not be possible" do
+        expect(@lock.unlock).to be_falsey
+      end
+
+      it "should not remove the lock file" do
+        @lock.unlock
+        expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
+      end
+
+      it "should still not be our lock" do
+        @lock.unlock
+        expect(@lock).not_to be_mine
+      end
+    end
+  end
+
   describe "with another process lock" do
     before(:each) do
       # fake our pid to be 1234
@@ -267,6 +279,30 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
       expect(@lock).not_to be_mine
     end
 
+    it "should be locked if the other process is a puppet gem" do
+      File.write(@lockfile, "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('ruby')
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
+      end
+      expect(@lock).to be_locked
+    end
+
+    it "should not be mine if the other process is a puppet gem" do
+      File.write(@lockfile, "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('ruby')
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
+      end
+      expect(@lock).to_not be_mine
+    end
+
     describe "#lock" do
       it "should not be possible" do
         expect(@lock.lock).to be_falsey