puppet 4.0.0 → 4.9.1

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

@@ -7,14 +7,30 @@ provider = Puppet::Type.type(:package).provider(:portage)
 describe provider do
   before do
     packagename="sl"
-    @resource = stub('resource', :[] => packagename,:should => true)
+    @resource = stub('resource', :should => true)
+    @resource.stubs(:[]).with(:name).returns(packagename)
+    @resource.stubs(:[]).with(:category).returns(nil)
+
+    unslotted_packagename = "dev-lang/ruby"
+    @unslotted_resource = stub('resource', :should => true)
+    @unslotted_resource.stubs(:[]).with(:name).returns(unslotted_packagename)
+    @unslotted_resource.stubs(:[]).with(:category).returns(nil)
+
+    slotted_packagename = "dev-lang/ruby:1.9"
+    @slotted_resource = stub('resource', :should => true)
+    @slotted_resource.stubs(:[]).with(:name).returns(slotted_packagename)
+    @slotted_resource.stubs(:[]).with(:category).returns(nil)
+
     @provider = provider.new(@resource)
-    
+    @unslotted_provider = provider.new(@unslotted_resource)
+    @slotted_provider = provider.new(@slotted_resource)
+
     portage   = stub(:executable => "foo",:execute => true)
     Puppet::Provider::CommandDefiner.stubs(:define).returns(portage)
 
     @nomatch_result = ""
-    @match_result   = "app-misc sl [] [] http://www.tkl.iis.u-tokyo.ac.jp/~toyoda/index_e.html http://www.izumix.org.uk/sl/ sophisticated graphical program which corrects your miss typing\n"
+    @match_result   = "app-misc sl [] [] [] [] http://www.tkl.iis.u-tokyo.ac.jp/~toyoda/index_e.html http://www.izumix.org.uk/sl/ sophisticated graphical program which corrects your miss typing\n"
+    @slot_match_result = "dev-lang ruby [2.0.0] [2.1.0] [1.8.7:1.8,1.9.2:1.9,2.0.0:2.0] [1.9.3:1.9,2.0.1:2.0,2.1.0:2.1] http://www.ruby-lang.org/ An object-oriented scripting language\n"
   end
 
   it "is versionable" do
@@ -27,20 +43,20 @@ describe provider do
 
   it "uses :emerge to install packages" do
     @provider.expects(:emerge)
-    
+
     @provider.install
   end
 
   it "uses query to find the latest package" do
     @provider.expects(:query).returns({:versions_available => "myversion"})
-    
+
     @provider.latest
   end
 
   it "uses eix to search the lastest version of a package" do
     @provider.stubs(:update_eix)
     @provider.expects(:eix).returns(StringIO.new(@match_result))
-    
+
     @provider.query
   end
 
@@ -56,14 +72,54 @@ describe provider do
     @provider.stubs(:update_eix)
     @provider.expects(:eix).returns(StringIO.new(@match_result))
     @provider.class.expects(:eix_search_arguments).returns([])
-    
+
     @provider.query
   end
 
   it "can handle search output with empty square brackets" do
     @provider.stubs(:update_eix)
     @provider.expects(:eix).returns(StringIO.new(@match_result))
-    
+
     expect(@provider.query[:name]).to eq("sl")
   end
+
+  it "can provide the package name without slot" do
+    expect(@slotted_provider.package_name_without_slot).to eq("dev-lang/ruby")
+  end
+
+  it "can extract the slot from the package name" do
+    expect(@slotted_provider.package_slot).to eq("1.9")
+  end
+
+  it "returns nil for as the slot when no slot is specified" do
+    expect(@provider.package_slot).to be_nil
+  end
+
+  it "provides correct package atoms for unslotted packages" do
+    expect(@provider.package_atom_with_version("1.0")).to eq("=sl-1.0")
+  end
+
+  it "provides correct package atoms for slotted packages" do
+    expect(@slotted_provider.package_atom_with_version("1.9.3")).to eq("=dev-lang/ruby-1.9.3:1.9")
+  end
+
+  it "can handle search output with slots for unslotted packages" do
+    @unslotted_provider.stubs(:update_eix)
+    @unslotted_provider.expects(:eix).returns(StringIO.new(@slot_match_result))
+
+    result = @unslotted_provider.query
+    expect(result[:name]).to eq("ruby")
+    expect(result[:ensure]).to eq("2.0.0")
+    expect(result[:version_available]).to eq("2.1.0")
+  end
+
+  it "can handle search output with slots" do
+    @slotted_provider.stubs(:update_eix)
+    @slotted_provider.expects(:eix).returns(StringIO.new(@slot_match_result))
+
+    result = @slotted_provider.query
+    expect(result[:name]).to eq("ruby")
+    expect(result[:ensure]).to eq("1.9.2")
+    expect(result[:version_available]).to eq("1.9.3")
+  end
 end

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

@@ -12,6 +12,7 @@ describe provider_class do
     chkconfig 0 1.3.30.2 2.el5 x86_64
     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
     RPM_OUTPUT
   end
 
@@ -116,7 +117,18 @@ describe provider_class do
           :ensure => "1.3.30.2-2.el5",
         }
       )
-      expect(installed_packages.last.properties).to eq(
+      expect(installed_packages[3].properties).to eq(
+        {
+          :provider => :rpm,
+          :name => "myresource",
+          :epoch => "0",
+          :version => "1.2.3.4",
+          :release => "5.el4",
+          :arch => "noarch",
+          :ensure => "1.2.3.4-5.el4",
+        }
+      )
+      expect(installed_packages[4].properties).to eq(
         {
           :provider    => :rpm,
           :name        => "mysummaryless",
@@ -127,6 +139,17 @@ describe provider_class do
           :ensure      => "1.2.3.4-5.el4",
         }
       )
+      expect(installed_packages[5].properties).to eq(
+        {
+          :provider    => :rpm,
+          :name        => "tomcat",
+          :epoch       => "1",
+          :version     => "1.2.3.4",
+          :release     => "5.el4",
+          :arch        => "x86_64",
+          :ensure      => "1:1.2.3.4-5.el4",
+        }
+      )
     end
   end
 
@@ -180,7 +203,7 @@ describe provider_class do
   describe "#latest" do
     it "retrieves version string after querying rpm for version from source file" do
       resource.expects(:[]).with(:source).returns('source-string')
-      Puppet::Util::Execution.expects(:execfail).with(["/bin/rpm", "-q", "--qf", nevra_format, "-p", "source-string"], Puppet::Error).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+      Puppet::Util::Execution.expects(:execfail).with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"], Puppet::Error).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
       expect(provider.latest).to eq("1.2.3.4-5.el4")
     end
   end
@@ -195,7 +218,7 @@ describe provider_class do
 
     describe "on a modern RPM" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", nevra_format], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
       end
 
       let(:rpm_version) { "RPM version 4.10.0\n" }
@@ -208,7 +231,7 @@ describe provider_class do
 
     describe "on an ancient RPM" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "myresource", '', '', '--qf', nevra_format], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "myresource", '', '', '--qf', "'#{nevra_format}'"], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
       end
 
       let(:rpm_version) { "RPM version 3.0.6\n" }
@@ -221,7 +244,7 @@ describe provider_class do
 
     describe "when uninstalled with options" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", nevra_format], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
       end
 
       let(:resource) do
@@ -243,7 +266,7 @@ describe provider_class do
   describe "parsing" do
     def parser_test(rpm_output_string, gold_hash, number_of_debug_logs = 0)
       Puppet.expects(:debug).times(number_of_debug_logs)
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", nevra_format], execute_options).returns(rpm_output_string)
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"], execute_options).returns(rpm_output_string)
       expect(provider.query).to eq(gold_hash)
     end
 
@@ -257,7 +280,7 @@ describe provider_class do
         :release => 'release',
         :arch => 'arch',
         :provider => :rpm,
-        :ensure => 'version-release',
+        :ensure => 'epoch:version-release',
       }
     end
     let(:line) { 'name epoch version release arch' }
@@ -269,7 +292,7 @@ describe provider_class do
           line.gsub(field, delimiter),
           package_hash.merge(
             field.to_sym => delimiter,
-            :ensure => 'version-release'.gsub(field, delimiter)
+            :ensure => 'epoch:version-release'.gsub(field, delimiter)
           )
         )
       end
@@ -283,7 +306,7 @@ describe provider_class do
     describe "when the package is not found" do
       before do
         Puppet.expects(:debug).never
-        expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", nevra_format]
+        expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"]
         Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not installed")
       end
 
@@ -294,7 +317,7 @@ describe provider_class 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']
         Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not provided")
         expect(provider.query).to be_nil
       end
@@ -302,7 +325,7 @@ describe provider_class 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}'"]
       Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not installed")
       Puppet::Util::Execution.expects(:execute).with(expected_args + ["--whatprovides"], execute_options).returns "myresource 0 1.2.3.4 5.el4 noarch\n"
       expect(provider.query).to eq({
@@ -481,4 +504,138 @@ describe provider_class do
     it { expect(provider.rpmvercmp("1", "0")).to eq(1) }
   end
 
+  describe 'package evr parsing' do
+
+    it 'should parse full simple evr' do
+      v = provider.rpm_parse_evr('0:1.2.3-4.el5')
+      expect(v[:epoch]).to eq('0')
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4.el5')
+    end
+
+    it 'should parse version only' do
+      v = provider.rpm_parse_evr('1.2.3')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq(nil)
+    end
+
+    it 'should parse version-release' do
+      v = provider.rpm_parse_evr('1.2.3-4.5.el6')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4.5.el6')
+    end
+
+    it 'should parse release with git hash' do
+      v = provider.rpm_parse_evr('1.2.3-4.1234aefd')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4.1234aefd')
+    end
+
+    it 'should parse single integer versions' do
+      v = provider.rpm_parse_evr('12345')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('12345')
+      expect(v[:release]).to eq(nil)
+    end
+
+    it 'should parse text in the epoch to 0' do
+      v = provider.rpm_parse_evr('foo0:1.2.3-4')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4')
+    end
+
+    it 'should parse revisions with text' do
+      v = provider.rpm_parse_evr('1.2.3-SNAPSHOT20140107')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('SNAPSHOT20140107')
+    end
+
+    # test cases for PUP-682
+    it 'should parse revisions with text and numbers' do
+      v = provider.rpm_parse_evr('2.2-SNAPSHOT20121119105647')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('2.2')
+      expect(v[:release]).to eq('SNAPSHOT20121119105647')
+    end
+
+  end
+
+  describe 'rpm evr comparison' do
+
+    # currently passing tests
+    it 'should evaluate identical version-release as equal' do
+      v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => '1.el5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '1.el5'})
+      expect(v).to eq(0)
+    end
+
+    it 'should evaluate identical version as equal' do
+      v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => nil},
+                                  {:epoch => '0', :version => '1.2.3', :release => nil})
+      expect(v).to eq(0)
+    end
+
+    it 'should evaluate identical version but older release as less' do
+      v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => '1.el5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
+      expect(v).to eq(-1)
+    end
+
+    it 'should evaluate identical version but newer release as greater' do
+      v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => '3.el5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
+      expect(v).to eq(1)
+    end
+
+    it 'should evaluate a newer epoch as greater' do
+      v = provider.rpm_compareEVR({:epoch => '1', :version => '1.2.3', :release => '4.5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '4.5'})
+      expect(v).to eq(1)
+    end
+
+    # these tests describe PUP-1244 logic yet to be implemented
+    it 'should evaluate any version as equal to the same version followed by release' do
+      v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => nil},
+                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
+      expect(v).to eq(0)
+    end
+
+    # test cases for PUP-682
+    it 'should evaluate same-length numeric revisions numerically' do
+      expect(provider.rpm_compareEVR({:epoch => '0', :version => '2.2', :release => '405'},
+                               {:epoch => '0', :version => '2.2', :release => '406'})).to eq(-1)
+    end
+
+  end
+
+  describe 'version segment comparison' do
+
+    it 'should treat two nil values as equal' do
+      v = provider.compare_values(nil, nil)
+      expect(v).to eq(0)
+    end
+
+    it 'should treat a nil value as less than a non-nil value' do
+      v = provider.compare_values(nil, '0')
+      expect(v).to eq(-1)
+    end
+
+    it 'should treat a non-nil value as greater than a nil value' do
+      v = provider.compare_values('0', nil)
+      expect(v).to eq(1)
+    end
+
+    it 'should pass two non-nil values on to rpmvercmp' do
+      provider.stubs(:rpmvercmp) { 0 }
+      provider.expects(:rpmvercmp).with('s1', 's2')
+      provider.compare_values('s1', 's2')
+    end
+
+  end
+
 end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+# Note that much of the functionality of the tdnf provider is already tested with yum provider tests,
+# as yum is the parent provider, via dnf
+
+provider_class = Puppet::Type.type(:package).provider(:tdnf)
+
+context 'default' do
+  it 'should be the default provider on PhotonOS' do
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystem).returns("PhotonOS")
+    expect(provider_class).to be_default
+  end
+end
+
+describe provider_class do
+  it_behaves_like 'RHEL package provider', provider_class, 'tdnf'
+end

data/spec/unit/provider/package/windows/exe_package_spec.rb

@@ -34,7 +34,6 @@ describe Puppet::Provider::Package::Windows::ExePackage do
     {
       'DisplayName'      => ['My App', ''],
       'UninstallString'  => ['E:\uninstall.exe', ''],
-      'SystemComponent'  => [nil, 1],
       'WindowsInstaller' => [nil, 1],
       'ParentKeyName'    => [nil, 'Uber Product'],
       'Security Update'  => [nil, 'KB890830'],

data/spec/unit/provider/package/windows/msi_package_spec.rb

@@ -48,7 +48,6 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
 
     {
       'DisplayName'      => ['My App', ''],
-      'SystemComponent'  => [nil, 1],
       'WindowsInstaller' => [1, nil],
     }.each_pair do |k, arr|
       it "should accept '#{k}' with value '#{arr[0]}'" do

data/spec/unit/provider/package/windows/package_spec.rb

@@ -61,7 +61,10 @@ describe Puppet::Provider::Package::Windows::Package do
 
       expect {
         subject.with_key{ |key, values| }
-      }.to raise_error(Puppet::Util::Windows::Error, /Access is denied/)
+      }.to raise_error do |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        expect(error.code).to eq(5) # ERROR_ACCESS_DENIED
+      end
     end
   end
 
@@ -132,6 +135,47 @@ describe Puppet::Provider::Package::Windows::Package do
     end
   end
 
+  context '::get_display_name' do
+    it 'should return nil if values is nil' do
+      expect(subject.get_display_name(nil)).to be_nil
+    end
+
+    it 'should return empty if values is empty' do
+      reg_values =  {}
+      expect(subject.get_display_name(reg_values)).to eq('')
+    end
+
+    it 'should return DisplayName when available' do
+      reg_values =  { 'DisplayName' => 'Google' }
+      expect(subject.get_display_name(reg_values)).to eq('Google')
+    end
+
+    it 'should return DisplayName when available, even when QuietDisplayName is also available' do
+      reg_values =  { 'DisplayName' => 'Google', 'QuietDisplayName' => 'Google Quiet' }
+      expect(subject.get_display_name(reg_values)).to eq('Google')
+    end
+
+    it 'should return QuietDisplayName when available if DisplayName is empty' do
+      reg_values =  { 'DisplayName' => '', 'QuietDisplayName' =>'Google Quiet' }
+      expect(subject.get_display_name(reg_values)).to eq('Google Quiet')
+    end
+
+    it 'should return QuietDisplayName when DisplayName is not available' do
+      reg_values =  { 'QuietDisplayName' =>'Google Quiet' }
+      expect(subject.get_display_name(reg_values)).to eq('Google Quiet')
+    end
+
+    it 'should return empty when DisplayName is empty and QuietDisplay name is not available' do
+      reg_values =  { 'DisplayName' => '' }
+      expect(subject.get_display_name(reg_values)).to eq('')
+    end
+
+    it 'should return empty when DisplayName is empty and QuietDisplay name is empty' do
+      reg_values =  { 'DisplayName' => '', 'QuietDisplayName' =>'' }
+      expect(subject.get_display_name(reg_values)).to eq('')
+    end
+  end
+
   it 'should implement instance methods' do
     pkg = subject.new('orca', '5.0')
 

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

@@ -131,7 +131,10 @@ describe Puppet::Type.type(:package).provider(:windows) do
 
       expect do
         provider.install
-      end.to raise_error(Puppet::Util::Windows::Error, /Access is denied/)
+      end.to raise_error do |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        expect(error.code).to eq(5) # ERROR_ACCESS_DENIED
+      end
     end
   end
 
@@ -183,7 +186,10 @@ describe Puppet::Type.type(:package).provider(:windows) do
 
       expect do
         provider.uninstall
-      end.to raise_error(Puppet::Util::Windows::Error, /Failed to uninstall.*Access is denied/)
+      end.to raise_error do |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        expect(error.code).to eq(5) # ERROR_ACCESS_DENIED
+      end
     end
   end