puppet 6.10.1 → 6.11.0

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

@@ -8,11 +8,13 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
   let(:vim_installed_output) { "install ok installed vim 2:7.3.547-6ubuntu5\n" }
   let(:all_installed_io) { StringIO.new([bash_installed_output, vim_installed_output].join) }
   let(:args) { ['-W', '--showformat', %Q{'${Status} ${Package} ${Version}\\n'}] }
+  let(:args_with_provides) { ['/bin/dpkg-query','-W', '--showformat', %Q{'${Status} ${Package} ${Version} [${Provides}]\\n'}]}
   let(:execute_options) do
     {:failonfail => true, :combine => true, :custom_environment => {}}
   end
-  let(:resource_name) { 'package' }
+  let(:resource_name) { 'python' }
   let(:resource) { double('resource', :[] => resource_name) }
+  let(:dpkg_query_result) { 'install ok installed python 2.7.13' }
   let(:provider) { described_class.new(resource) }
 
   it "has documentation" do
@@ -68,105 +70,247 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
     end
 
+    def dpkg_query_execution_with_multiple_args_returns(output, *args)
+      args.each do |arg|
+        allow(Puppet::Util::Execution).to receive(:execute).with(arg, execute_options).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
+      end
+    end
+
     before do
       allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
     end
 
     it "considers the package purged if dpkg-query fails" do
+      allow(resource).to receive(:allow_virtual?).and_return(false)
       allow(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("eh"))
 
       expect(provider.query[:ensure]).to eq(:purged)
     end
 
-    it "returns a hash of the found package status for an installed package" do
-      dpkg_query_execution_returns(bash_installed_output)
-
-      expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg})
-    end
-
-    it "considers the package absent if the dpkg-query result cannot be interpreted" do
-      dpkg_query_execution_returns('some-bad-data')
-
-      expect(provider.query[:ensure]).to eq(:absent)
-    end
-
-    it "fails if an error is discovered" do
-      dpkg_query_execution_returns(bash_installed_output.gsub("ok","error"))
+    context "allow_virtual true" do
+      before do
+        allow(resource).to receive(:allow_virtual?).and_return(true)
+      end
 
-      expect { provider.query }.to raise_error(Puppet::Error)
+      context "virtual_packages" do
+        let(:query_output) { 'install ok installed python 2.7.13 [python-ctypes, python-email, python-importlib, python-profiler, python-wsgiref, python-gold]' }
+        let(:virtual_packages_query_args) do
+          result = args_with_provides.dup
+          result.push(resource_name)
+        end
+
+        it "considers the package purged if dpkg-query fails" do
+          allow(Puppet::Util::Execution).to receive(:execute).with(args_with_provides, execute_options).and_raise(Puppet::ExecutionFailure.new("eh"))
+          expect(provider.query[:ensure]).to eq(:purged)
+        end
+
+        it "returns a hash of the found package status for an installed package" do
+          dpkg_query_execution_with_multiple_args_returns(query_output, args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result, args, query_args)
+          expect(provider.query).to eq(:ensure => "2.7.13", :error => "ok", :desired => "install", :name => "python", :status => "installed", :provider => :dpkg)
+        end
+
+        it "considers the package absent if the dpkg-query result cannot be interpreted" do
+          dpkg_query_execution_with_multiple_args_returns('some-bad-data',args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns('some-bad-data', args, query_args)
+          expect(provider.query[:ensure]).to eq(:absent)
+        end
+
+        it "fails if an error is discovered" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("ok","error"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("ok","error"), args, query_args)
+          expect { provider.query }.to raise_error(Puppet::Error,  /Package python, version 2.7.13 is in error state: error/)
+        end
+
+        it "considers the package purged if it is marked 'not-installed" do
+          not_installed_query = query_output.gsub("installed", "not-installed").delete!('2.7.13')
+          dpkg_query_execution_with_multiple_args_returns(not_installed_query, args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("installed", "not-installed").delete!('2.7.13'), args, query_args)
+          expect(provider.query[:ensure]).to eq(:purged)
+        end
+
+        it "considers the package absent if it is marked 'config-files'" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("installed","config-files"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("installed","config-files"), args, query_args)
+          expect(provider.query[:ensure]).to eq(:absent)
+        end
+
+        it "considers the package absent if it is marked 'half-installed'" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("installed","half-installed"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("installed","half-installed"), args, query_args)
+          expect(provider.query[:ensure]).to eq(:absent)
+        end
+
+        it "considers the package absent if it is marked 'unpacked'" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("installed","unpacked"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("installed","unpacked"), args, query_args)
+          expect(provider.query[:ensure]).to eq(:absent)
+        end
+
+        it "considers the package absent if it is marked 'half-configured'" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("installed","half-configured"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("installed","half-configured"), args, query_args)
+          expect(provider.query[:ensure]).to eq(:absent)
+        end
+
+        it "considers the package held if its state is 'hold'" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("install","hold"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("install","hold"), args, query_args)
+          expect(provider.query[:ensure]).to eq(:held)
+        end
+
+        context "regex check for query search" do
+          let(:resource_name) { 'python-email' }
+          let(:resource) { instance_double('Puppet::Type::Package') }
+          before do
+            allow(resource).to receive(:[]).with(:name).and_return(resource_name)
+            allow(resource).to receive(:[]=)
+          end
+
+          it "checks if virtual package regex for query is correctand phisical package is installed" do
+            dpkg_query_execution_with_multiple_args_returns(query_output,args_with_provides,virtual_packages_query_args)
+            dpkg_query_execution_with_multiple_args_returns(dpkg_query_result, args, query_args)
+            expect(provider.query).to match({:desired=>"install", :ensure=>"2.7.13", :error=>"ok", :name=>"python", :provider=>:dpkg, :status=>"installed"})
+          end
+
+          context "regex check with no partial matching" do
+            let(:resource_name) { 'python-em' }
+
+            it "checks if virtual package regex for query is correct and regext dosen't make partial matching" do
+              expect(provider).to receive(:dpkgquery).with('-W', '--showformat', %Q{'${Status} ${Package} ${Version} [${Provides}]\\n'}).and_return(query_output)
+              expect(provider).to receive(:dpkgquery).with('-W', '--showformat', %Q{'${Status} ${Package} ${Version}\\n'}, resource_name).and_return("#{dpkg_query_result} #{resource_name}")
+
+              provider.query
+            end
+
+            context "regex check with special characters" do
+              let(:resource_name) { 'g++' }
+
+              it "checks if virtual package regex for query is correct and regext dosen't make partial matching" do
+                expect(Puppet).to_not receive(:info).with(/is virtual/)
+                expect(provider).to receive(:dpkgquery).with('-W', '--showformat', %Q{'${Status} ${Package} ${Version} [${Provides}]\\n'}).and_return(query_output)
+                expect(provider).to receive(:dpkgquery).with('-W', '--showformat', %Q{'${Status} ${Package} ${Version}\\n'}, resource_name).and_return("#{dpkg_query_result} #{resource_name}")
+
+                provider.query
+              end
+            end
+          end
+        end
+      end
     end
 
-    it "considers the package purged if it is marked 'not-installed'" do
-      not_installed_bash = bash_installed_output.gsub("installed", "not-installed")
-      not_installed_bash.gsub!(bash_version, "")
-      dpkg_query_execution_returns(not_installed_bash)
-
-      expect(provider.query[:ensure]).to eq(:purged)
-    end
+    context "allow_virtual false" do
+      before do
+        allow(resource).to receive(:allow_virtual?).and_return(false)
+      end
 
-    it "considers the package absent if it is marked 'config-files'" do
-      dpkg_query_execution_returns(bash_installed_output.gsub("installed","config-files"))
-      expect(provider.query[:ensure]).to eq(:absent)
-    end
+      it "returns a hash of the found package status for an installed package" do
+        dpkg_query_execution_returns(bash_installed_output)
 
-    it "considers the package absent if it is marked 'half-installed'" do
-      dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-installed"))
-      expect(provider.query[:ensure]).to eq(:absent)
-    end
+        expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg})
+      end
 
-    it "considers the package absent if it is marked 'unpacked'" do
-      dpkg_query_execution_returns(bash_installed_output.gsub("installed","unpacked"))
-      expect(provider.query[:ensure]).to eq(:absent)
-    end
+      it "considers the package absent if the dpkg-query result cannot be interpreted" do
+        allow(resource).to receive(:allow_virtual?).and_return(false)
+        dpkg_query_execution_returns('some-bad-data')
+        expect(provider.query[:ensure]).to eq(:absent)
+      end
 
-    it "considers the package absent if it is marked 'half-configured'" do
-      dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-configured"))
-      expect(provider.query[:ensure]).to eq(:absent)
-    end
+      it "fails if an error is discovered" do
+        dpkg_query_execution_returns(bash_installed_output.gsub("ok","error"))
+        expect { provider.query }.to raise_error(Puppet::Error)
+      end
 
-    it "considers the package held if its state is 'hold'" do
-      dpkg_query_execution_returns(bash_installed_output.gsub("install","hold"))
-      expect(provider.query[:ensure]).to eq(:held)
-    end
+      it "considers the package purged if it is marked 'not-installed'" do
+        not_installed_bash = bash_installed_output.gsub("installed", "not-installed")
+        not_installed_bash.gsub!(bash_version, "")
+        dpkg_query_execution_returns(not_installed_bash)
 
-    context "parsing tests" do
-      let(:resource_name) { 'name' }
-      let(:package_hash) do
-        {
-          :desired => 'desired',
-          :error => 'ok',
-          :status => 'status',
-          :name => resource_name,
-          :ensure => 'ensure',
-          :provider => :dpkg,
-        }
-      end
-      let(:package_not_found_hash) do
-        {:ensure => :purged, :status => 'missing', :name => resource_name, :error => 'ok'}
+        expect(provider.query[:ensure]).to eq(:purged)
       end
 
-      def parser_test(dpkg_output_string, gold_hash, number_of_debug_logs = 0)
-        dpkg_query_execution_returns(dpkg_output_string)
-        expect(Puppet).not_to receive(:warning)
-        expect(Puppet).to receive(:debug).exactly(number_of_debug_logs).times
+      it "considers the package absent if it is marked 'config-files'" do
+        dpkg_query_execution_returns(bash_installed_output.gsub("installed","config-files"))
+        expect(provider.query[:ensure]).to eq(:absent)
+      end
 
-        expect(provider.query).to eq(gold_hash)
+      it "considers the package absent if it is marked 'half-installed'" do
+        dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-installed"))
+        expect(provider.query[:ensure]).to eq(:absent)
       end
 
-      it "parses properly even if optional ensure field is missing" do
-        no_ensure = 'desired ok status name '
-        parser_test(no_ensure, package_hash.merge(:ensure => ''))
+      it "considers the package absent if it is marked 'unpacked'" do
+        dpkg_query_execution_returns(bash_installed_output.gsub("installed","unpacked"))
+        expect(provider.query[:ensure]).to eq(:absent)
       end
 
-      it "provides debug logging of unparsable lines" do
-        parser_test('an unexpected dpkg msg with an exit code of 0', package_not_found_hash.merge(:ensure => :absent), 1)
+      it "considers the package absent if it is marked 'half-configured'" do
+        dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-configured"))
+        expect(provider.query[:ensure]).to eq(:absent)
       end
 
-      it "does not log if execution returns with non-zero exit code" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("failed"))
-        expect(Puppet).not_to receive(:debug)
+      it "considers the package held if its state is 'hold'" do
+        dpkg_query_execution_returns(bash_installed_output.gsub("install","hold"))
+        expect(provider.query[:ensure]).to eq(:held)
+      end
 
-        expect(provider.query).to eq(package_not_found_hash)
+      context "parsing tests" do
+        let(:resource_name) { 'name' }
+        let(:package_hash) do
+          {
+            :desired => 'desired',
+            :error => 'ok',
+            :status => 'status',
+            :name => resource_name,
+            :ensure => 'ensure',
+            :provider => :dpkg,
+          }
+        end
+
+        let(:package_not_found_hash) do
+          {:ensure => :purged, :status => 'missing', :name => resource_name, :error => 'ok'}
+        end
+
+        let(:output) {'an unexpected dpkg msg with an exit code of 0'}
+
+        def parser_test(dpkg_output_string, gold_hash, number_of_debug_logs = 0)
+          dpkg_query_execution_returns(dpkg_output_string)
+          expect(Puppet).not_to receive(:warning)
+          expect(Puppet).to receive(:debug).exactly(number_of_debug_logs).times
+
+          expect(provider.query).to eq(gold_hash)
+        end
+
+        it "parses properly even if optional ensure field is missing" do
+          no_ensure = 'desired ok status name '
+          parser_test(no_ensure, package_hash.merge(:ensure => ''))
+        end
+
+        it "provides debug logging of unparsable lines with allow_virtual enabled" do
+          allow(resource).to receive(:allow_virtual?).and_return(true)
+          dpkg_query_execution_with_multiple_args_returns(output, args_with_provides, query_args)
+          expect(Puppet).not_to receive(:warning)
+          expect(Puppet).to receive(:debug).exactly(1).times
+          expect(provider.query).to eq(package_not_found_hash.merge(:ensure => :absent))
+        end
+
+        it "provides debug logging of unparsable lines" do
+          parser_test('an unexpected dpkg msg with an exit code of 0', package_not_found_hash.merge(:ensure => :absent), 1)
+        end
+
+        it "does not log if execution returns with non-zero exit code with allow_virtual enabled" do
+          allow(resource).to receive(:allow_virtual?).and_return(true)
+          expect(Puppet::Util::Execution).to receive(:execute).with(args_with_provides, execute_options).and_raise(Puppet::ExecutionFailure.new("failed"))
+          expect(Puppet).not_to receive(:debug)
+          expect(provider.query).to eq(package_not_found_hash)
+        end
+
+        it "does not log if execution returns with non-zero exit code" do
+          expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("failed"))
+          expect(Puppet).not_to receive(:debug)
+
+          expect(provider.query).to eq(package_not_found_hash)
+        end
       end
     end
   end
@@ -222,7 +366,6 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
     end
 
     it "installs first if package is not present and ensure holding" do
-
       allow(provider).to receive(:execute)
       allow(provider).to receive(:package_not_installed?).and_return(true)
       expect(provider).to receive(:install).once
@@ -258,8 +401,8 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
 
   context "when determining latest available version" do
     it "returns the version found by dpkg-deb" do
-      expect(resource).to receive(:[]).with(:source).and_return("myfile")
-      expect(provider).to receive(:dpkg_deb).with(any_args, "myfile").and_return("package\t1.0")
+      expect(resource).to receive(:[]).with(:source).and_return("python")
+      expect(provider).to receive(:dpkg_deb).with('--show', "python").and_return("package\t1.0")
       expect(provider.latest).to eq("1.0")
     end
 
@@ -287,9 +430,26 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
     provider.purge
   end
 
-  it "raises error if package name is nil" do
-    expect {provider.package_not_installed?(nil)}.to raise_error(ArgumentError,"Package name is nil or empty")
-    expect {provider.package_not_installed?("")}.to raise_error(ArgumentError,"Package name is nil or empty")
+  context "package_not_installed?" do
+    context "allow_virtual false" do
+        before do
+          allow(resource).to receive(:allow_virtual?).and_return(false)
+        end
+
+      it "returns true if package is not found" do
+        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_raise(Puppet::ExecutionFailure.new("eh"))
+        expect(provider.package_not_installed?).to eq(true)
+      end
+
+      it "returns true if package is not installed" do
+        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("unknown ok not-installed #{resource_name}")
+        expect(provider.package_not_installed?).to eq(true)
+      end
+
+      it "returns false if package is installed" do
+        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("install ok installed resource_name 1.2.3")
+        expect(provider.package_not_installed?).to eq(false)
+      end
+    end
   end
 end
-

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-osfamilies = { 'windows' => ['pip.exe'], 'other' => ['pip', 'pip-python'] }
+osfamilies = { 'windows' => ['pip.exe'], 'other' => ['pip', 'pip-python', 'pip2', 'pip-2'] }
 
 describe Puppet::Type.type(:package).provider(:pip) do
 
@@ -205,6 +205,13 @@ describe Puppet::Type.type(:package).provider(:pip) do
         @resource[:name] = "fake_package"
         expect(@provider.latest).to eq(nil)
       end
+
+      it "should use 'install_options' when specified" do
+        expect(Puppet::Util::Execution).to receive(:execpipe).with(array_including([["--index=https://fake.example.com"]])).once
+        @resource[:name] = "fake_package"
+        @resource[:install_options] = ['--index' => 'https://fake.example.com']
+        expect(@provider.latest).to eq(nil)
+      end
     end
 
     context "with pip version >= 1.5.4" do
@@ -259,6 +266,13 @@ describe Puppet::Type.type(:package).provider(:pip) do
         latest = @provider.latest
         expect(latest).to eq('15.0.2')
       end
+
+      it "should use 'install_options' when specified" do
+        expect(Puppet::Util::Execution).to receive(:execpipe).with(array_including([["--index=https://fake.example.com"]])).once
+        @resource[:name] = "fake_package"
+        @resource[:install_options] = ['--index' => 'https://fake.example.com']
+        expect(@provider.latest).to eq(nil)
+      end
     end
   end
 
@@ -349,12 +363,43 @@ describe Puppet::Type.type(:package).provider(:pip) do
   end
 
   context "pip_version" do
+    let(:pip) { '/fake/bin/pip' }
+
     it "should look up version if pip is present" do
-      allow(described_class).to receive(:pip_cmd).and_return('/fake/bin/pip')
-      p = double("process")
-      expect(p).to receive(:collect).and_yield('pip 8.0.2 from /usr/local/lib/python2.7/dist-packages (python 2.7)')
-      expect(described_class).to receive(:execpipe).with(['/fake/bin/pip', '--version']).and_yield(p)
-      expect(described_class.pip_version('/fake/bin/pip')).to eq('8.0.2')
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      process = ['pip 8.0.2 from /usr/local/lib/python2.7/dist-packages (python 2.7)']
+      allow(described_class).to receive(:execpipe).with([pip, '--version']).and_yield(process)
+
+      expect(described_class.pip_version(pip)).to eq('8.0.2')
+    end
+
+    it "parses multiple lines of output" do
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      process = [
+        "/usr/local/lib/python2.7/dist-packages/urllib3/contrib/socks.py:37: DependencyWarning: SOCKS support in urllib3 requires the installation of optional dependencies: specifically, PySocks. For more information, see https://urllib3.readthedocs.io/en/latest/contrib.html#socks-proxies",
+        "  DependencyWarning",
+        "pip 1.5.6 from /usr/lib/python2.7/dist-packages (python 2.7)"
+      ]
+      allow(described_class).to receive(:execpipe).with([pip, '--version']).and_yield(process)
+
+      expect(described_class.pip_version(pip)).to eq('1.5.6')
+    end
+
+    it "raises if there isn't a version string" do
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      allow(described_class).to receive(:execpipe).with([pip, '--version']).and_yield([""])
+      expect {
+        described_class.pip_version(pip)
+      }.to raise_error(Puppet::Error, 'Cannot resolve pip version')
+    end
+
+    it "quotes commands with spaces" do
+      pip = 'C:\Program Files\Python27\Scripts\pip.exe'
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      process = ["pip 18.1 from c:\program files\python27\lib\site-packages\pip (python 2.7)\r\n"]
+      allow(described_class).to receive(:execpipe).with(["\"#{pip}\"", '--version']).and_yield(process)
+
+      expect(described_class.pip_version(pip)).to eq('18.1')
     end
   end