puppet 5.5.16 → 5.5.21

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

@@ -9,6 +9,8 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     myresource 0 1.2.3.4 5.el4 noarch
     mysummaryless 0 1.2.3.4 5.el4 noarch
     tomcat 1 1.2.3.4 5.el4 x86_64
+    kernel 1 1.2.3.4 5.el4 x86_64
+    kernel 1 1.2.3.6 5.el4 x86_64
     '
     RPM_OUTPUT
   end
@@ -57,7 +59,7 @@ describe Puppet::Type.type(:package).provider(:rpm) 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}'")
+          .with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}' | sort")
           .and_yield(packages)
 
         described_class.instances
@@ -69,7 +71,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
       it "excludes the --nosignature flag" do
         expect(Puppet::Util::Execution).to receive(:execpipe)
-          .with("/bin/rpm -qa  --nodigest --qf '#{nevra_format}'")
+          .with("/bin/rpm -qa  --nodigest --qf '#{nevra_format}' | sort")
           .and_yield(packages)
 
         described_class.instances
@@ -81,7 +83,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
       it "excludes the --nodigest flag" do
         expect(Puppet::Util::Execution).to receive(:execpipe)
-        .with("/bin/rpm -qa   --qf '#{nevra_format}'")
+        .with("/bin/rpm -qa   --qf '#{nevra_format}' | sort")
         .and_yield(packages)
 
         described_class.instances
@@ -90,7 +92,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
     it "returns an array of packages" do
       expect(Puppet::Util::Execution).to receive(:execpipe)
-        .with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'")
+        .with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}' | sort")
         .and_yield(packages)
 
       installed_packages = described_class.instances
@@ -161,6 +163,17 @@ describe Puppet::Type.type(:package).provider(:rpm) do
           :ensure      => "1:1.2.3.4-5.el4",
         }
       )
+      expect(installed_packages[6].properties).to eq(
+        {
+          :provider    => :rpm,
+          :name        => "kernel",
+          :epoch       => "1",
+          :version     => "1.2.3.4",
+          :release     => "5.el4",
+          :arch        => "x86_64",
+          :ensure      => "1:1.2.3.4-5.el4; 1:1.2.3.6-5.el4",
+        }
+      )
     end
   end
 
@@ -218,7 +231,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     it "retrieves version string after querying rpm for version from source file" 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"])
+        .with(["/bin/rpm", "-q", "--qf", "#{nevra_format}", "-p", "source-string"])
         .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       expect(provider.latest).to eq("1.2.3.4-5.el4")
     end
@@ -226,7 +239,7 @@ 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"])
+        .with(["/bin/rpm", "-q", "--qf", "#{nevra_format}", "-p", "source-string"])
         .and_raise(Puppet::ExecutionFailure, 'rpm command failed')
 
       expect {
@@ -248,7 +261,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", resource_name, '', '', '--qf', "'#{nevra_format}'"], execute_options)
+          .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
 
@@ -266,7 +279,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", resource_name, '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .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
 
@@ -290,7 +303,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "#{resource_name}.noarch", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .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
 
@@ -312,7 +325,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "#{resource_name}-1.2.3.4-5.el4", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .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
 
@@ -334,7 +347,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "#{resource_name}-1.2.3.4", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .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
 
@@ -358,7 +371,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", resource_name, '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
+          .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
 
@@ -374,7 +387,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     def parser_test(rpm_output_string, gold_hash, number_of_debug_logs = 0)
       expect(Puppet).to receive(:debug).exactly(number_of_debug_logs).times()
       expect(Puppet::Util::Execution).to receive(:execute)
-        .with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"], execute_options)
+        .with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "#{nevra_format}"], execute_options)
         .and_return(Puppet::Util::Execution::ProcessOutput.new(rpm_output_string, 0))
       expect(provider.query).to eq(gold_hash)
     end
@@ -413,7 +426,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     describe "when the package is not found" do
       before do
         expect(Puppet).not_to receive(:debug)
-        expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"]
+        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"))
@@ -426,7 +439,7 @@ 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']
+        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"))
@@ -436,7 +449,7 @@ 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}'"]
+      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"))
@@ -749,4 +762,125 @@ describe Puppet::Type.type(:package).provider(:rpm) do
       provider.compare_values('s1', 's2')
     end
   end
+
+
+  describe 'insync?' do
+    context 'for multiple versions' do
+      let(:is) { '1:1.2.3.4-5.el4; 1:5.6.7.8-5.el4' }
+      it 'returns true if there is match and feature is enabled' do
+        resource[:install_only] = true
+        resource[:ensure] = '1:1.2.3.4-5.el4'
+        expect(provider).to be_insync(is)
+      end
+      it 'returns false if there is match and feature is not enabled' do
+        resource[:ensure] = '1:1.2.3.4-5.el4'
+        expect(provider).to_not be_insync(is)
+      end
+      it 'returns false if no match and feature is enabled' do
+        resource[:install_only] = true
+        resource[:ensure] = '1:1.2.3.6-5.el4'
+        expect(provider).to_not be_insync(is)
+      end
+      it 'returns false if no match and feature is not enabled' do
+        resource[:ensure] = '1:1.2.3.6-5.el4'
+        expect(provider).to_not be_insync(is)
+      end
+    end
+    context 'for simple versions' do
+      let(:is) { '1:1.2.3.4-5.el4' }
+      it 'returns true if there is match and feature is enabled' do
+        resource[:install_only] = true
+        resource[:ensure] = '1:1.2.3.4-5.el4'
+        expect(provider).to be_insync(is)
+      end
+      it 'returns true if there is match and feature is not enabled' do
+        resource[:ensure] = '1:1.2.3.4-5.el4'
+        expect(provider).to be_insync(is)
+      end
+      it 'returns false if no match and feature is enabled' do
+        resource[:install_only] = true
+        resource[:ensure] = '1:1.2.3.6-5.el4'
+        expect(provider).to_not be_insync(is)
+      end
+      it 'returns false if no match and feature is not enabled' do
+        resource[:ensure] = '1:1.2.3.6-5.el4'
+        expect(provider).to_not be_insync(is)
+      end
+    end
+  end
+
+  describe 'rpm multiversion to hash' do
+    it 'should return empty hash for empty imput' do
+      package_hash = described_class.nevra_to_multiversion_hash('')
+      expect(package_hash).to eq({})
+    end
+
+    it 'should return package hash for one package input' do
+      package_list = <<-RPM_OUTPUT
+kernel-devel 1 1.2.3.4 5.el4 x86_64
+RPM_OUTPUT
+      package_hash = described_class.nevra_to_multiversion_hash(package_list)
+      expect(package_hash).to eq(
+        {
+          :arch => "x86_64",
+          :ensure => "1:1.2.3.4-5.el4",
+          :epoch => "1",
+          :name => "kernel-devel",
+          :provider => :rpm,
+          :release => "5.el4",
+          :version => "1.2.3.4",
+        }
+      )
+    end
+
+    it 'should return package hash with versions concatenated in ensure for two package input' do
+      package_list = <<-RPM_OUTPUT
+kernel-devel 1 1.2.3.4 5.el4 x86_64
+kernel-devel 1 5.6.7.8 5.el4 x86_64
+RPM_OUTPUT
+      package_hash = described_class.nevra_to_multiversion_hash(package_list)
+      expect(package_hash).to eq(
+        {
+          :arch => "x86_64",
+          :ensure => "1:1.2.3.4-5.el4; 1:5.6.7.8-5.el4",
+          :epoch => "1",
+          :name => "kernel-devel",
+          :provider => :rpm,
+          :release => "5.el4",
+          :version => "1.2.3.4",
+        }
+      )
+    end
+
+    it 'should return list of packages for one multiversion and one package input' do
+      package_list = <<-RPM_OUTPUT
+kernel-devel 1 1.2.3.4 5.el4 x86_64
+kernel-devel 1 5.6.7.8 5.el4 x86_64
+basesystem 0 8.0 5.1.1.el5.centos noarch
+RPM_OUTPUT
+      package_hash = described_class.nevra_to_multiversion_hash(package_list)
+      expect(package_hash).to eq(
+        [
+          {
+            :arch => "x86_64",
+            :ensure => "1:1.2.3.4-5.el4; 1:5.6.7.8-5.el4",
+            :epoch => "1",
+            :name => "kernel-devel",
+            :provider => :rpm,
+            :release => "5.el4",
+            :version => "1.2.3.4",
+          },
+          {
+            :provider => :rpm,
+            :name => "basesystem",
+            :epoch => "0",
+            :version => "8.0",
+            :release => "5.1.1.el5.centos",
+            :arch => "noarch",
+            :ensure => "8.0-5.1.1.el5.centos",
+          }
+        ]
+      )
+    end
+  end
 end

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

@@ -23,6 +23,13 @@ describe Puppet::Type.type(:package).provider(:yum) do
 
     before { allow(described_class).to receive(:command).with(:cmd).and_return("/usr/bin/yum") }
 
+  describe 'provider features' do
+    it { is_expected.to be_versionable }
+    it { is_expected.to be_install_options }
+    it { is_expected.to be_virtual_packages }
+    it { is_expected.to be_install_only }
+  end
+
     context "when installing" do
       it "should use the supplied source as the explicit path to a package to install" do
         resource[:ensure] = :present
@@ -47,6 +54,56 @@ describe Puppet::Type.type(:package).provider(:yum) do
         provider.install
       end
     end
+
+    describe 'with install_options' do
+      it 'can parse disable-repo with array of strings' do
+          resource[:install_options] = ['--disable-repo=dev*', '--disable-repo=prod*']
+          expect(provider).to receive(:execute) do | arr|
+            expect(arr[-3]).to eq(["--disable-repo=dev*", "--disable-repo=prod*"])
+          end
+          provider.install
+      end
+
+      it 'can parse disable-repo with array of hashes' do
+        resource[:install_options] = [{'--disable-repo' => 'dev*'}, {'--disable-repo' => 'prod*'}]
+        expect(provider).to receive(:execute) do | arr|
+          expect(arr[-3]).to eq(["--disable-repo=dev*", "--disable-repo=prod*"])
+        end
+        provider.install
+      end
+
+      it 'can parse enable-repo with array of strings' do
+          resource[:install_options] = ['--enable-repo=dev*', '--enable-repo=prod*']
+          expect(provider).to receive(:execute) do | arr|
+            expect(arr[-3]).to eq(["--enable-repo=dev*", "--enable-repo=prod*"])
+          end
+          provider.install
+      end
+
+      it 'can parse enable-repo with array of hashes' do
+        resource[:install_options] = [{'--enable-repo' => 'dev*'}, {'--disable-repo' => 'prod*'}]
+        expect(provider).to receive(:execute) do | arr|
+          expect(arr[-3]).to eq(["--enable-repo=dev*", "--disable-repo=prod*"])
+        end
+        provider.install
+      end
+
+      it 'can parse enable-repo with single hash' do
+        resource[:install_options] = [{'--enable-repo' => 'dev*','--disable-repo' => 'prod*'}]
+        expect(provider).to receive(:execute) do | arr|
+          expect(arr[-3]).to eq(["--disable-repo=prod*", "--enable-repo=dev*"])
+        end
+        provider.install
+      end
+
+      it 'can parse enable-repo with empty array' do
+        resource[:install_options] = []
+        expect(provider).to receive(:execute) do | arr|
+          expect(arr[-3]).to eq([])
+        end
+        provider.install
+      end
+    end
   end
 
   context "parsing the output of check-update" do
@@ -137,5 +194,14 @@ describe Puppet::Type.type(:package).provider(:yum) do
         expect(output).not_to include("Random plugin")
       end
     end
+
+    context "with subscription manager enabled " do
+      let(:check_update) { File.read(my_fixture("yum-check-update-subscription-manager.txt")) }
+      let(:output) { described_class.parse_updates(check_update) }
+
+      it "parses correctly formatted entries" do
+        expect(output['curl.x86_64']).to eq([{:name => 'curl', :epoch => '0', :version => '7.32.0', :release => '10.fc20', :arch => 'x86_64'}])
+      end
+    end
   end
 end

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"' }])

data/spec/unit/provider/package_targetable_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'puppet'
+require 'puppet/provider/package_targetable'
+require 'puppet/provider/package/gem'
+
+describe Puppet::Provider::Package::Targetable do
+  let(:provider) { Puppet::Type.type(:package).provider(:gem) }
+  let(:command)  { '/opt/bin/gem' }
+
+  describe "when prefetching" do
+    context "with a package without a command attribute" do
+      let(:resource) { Puppet::Type.type(:package).new(:name => 'noo', :provider => 'gem', :ensure => :present) }
+      let(:catalog)  { Puppet::Resource::Catalog.new }
+      let(:instance) { provider.new(resource) }
+      let(:packages) { { 'noo' => resource } }
+
+      it "should pass a command to the instances method of the provider" do
+        catalog.add_resource(resource)
+        expect(provider).to receive(:instances).with(nil).and_return([instance])
+        expect(provider.prefetch(packages)).to eq([nil]) # prefetch arbitrarily returns the array of commands for a provider in the catalog
+      end
+    end
+
+    context "with a package with a command attribute" do
+      let(:resource) { Puppet::Type.type(:package).new(:name => 'noo', :provider => 'gem', :ensure => :present) }
+      let(:resource_targeted) { Puppet::Type.type(:package).new(:name => 'yes', :provider => 'gem', :command => command, :ensure => :present) }
+      let(:catalog)  { Puppet::Resource::Catalog.new }
+      let(:instance) { provider.new(resource) }
+      let(:instance_targeted) { provider.new(resource_targeted) }
+      let(:packages) { { 'noo' => resource, 'yes' => resource_targeted } }
+
+      it "should pass the command to the instances method of the provider" do
+        catalog.add_resource(resource)
+        catalog.add_resource(resource_targeted)
+        expect(provider).to receive(:instances).with(nil).and_return([instance])
+        expect(provider).to receive(:instances).with(command).and_return([instance_targeted]).once
+        expect(provider.prefetch(packages)).to eq([nil, command]) # prefetch arbitrarily returns the array of commands for a provider in the catalog
+      end
+    end
+  end
+
+  describe "when validating a command" do
+    context "with no command" do
+      it "report not functional" do
+        expect { provider.validate_command(nil) }.to raise_error(Puppet::Error, "Provider gem package command is not functional on this host")
+      end
+    end
+    context "with a missing command" do
+      it "report does not exist" do
+        expect { provider.validate_command(command) }.to raise_error(Puppet::Error, "Provider gem package command '#{command}' does not exist on this host")
+      end
+    end
+    context "with an existing command" do
+      it "validates" do
+        allow(File).to receive(:file?).with(command).and_return(true)
+        expect { provider.validate_command(command) }.not_to raise_error
+      end
+    end
+  end
+end