puppet 6.15.0-x86-mingw32 → 6.19.1-x86-mingw32

data/spec/unit/provider/exec_spec.rb

@@ -49,9 +49,10 @@ describe Puppet::Provider::Exec do
         # we can't reference that in our manifest. Windows PATHs can contain
         # double quotes and trailing backslashes, which confuse HEREDOC
         # interpolation below. So sanitize it:
-        ENV['PATH'].split(File::PATH_SEPARATOR).map do |dir|
-          dir.gsub(/"/, '\"').gsub(/\\$/, '')
-        end.join(File::PATH_SEPARATOR)
+        ENV['PATH'].split(File::PATH_SEPARATOR)
+                   .map { |dir| dir.gsub(/"/, '\"').gsub(/\\$/, '') }
+                   .map { |dir| Pathname.new(dir).cleanpath.to_s }
+                   .join(File::PATH_SEPARATOR)
       else
         ENV['PATH']
       end

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

@@ -22,16 +22,26 @@ describe Puppet::Type.type(:package).provider(:aix) do
 
   context "when installing" do
     it "should install a package" do
+      allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => 'present', :status => :committed})
       expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
       @provider.install
     end
 
     it "should install a specific package version" do
       allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.4")
+      allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => '1.2.3.4', :status => :committed})
       expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage 1.2.3.4')
       @provider.install
     end
 
+    [:broken, :inconsistent].each do |state|
+      it "should fail if the installation resulted in a '#{state}' state" do
+        allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => 'present', :status => state})
+        expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
+        expect { @provider.install }.to raise_error(Puppet::Error, "Package 'mypackage' is in a #{state} state and requires manual intervention")
+      end
+    end
+
     it "should fail if the specified version is superseded" do
       @resource[:ensure] = '1.2.3.3'
       allow(@provider).to receive(:installp).and_return(<<-OUTPUT)
@@ -126,4 +136,23 @@ END
     expect(described_class).to receive(:execute).and_return('mypackage:mypackage.rte:1.8.6.4::I:T:::::N:A Super Cool Package::::0::\n')
     described_class.prefetch({ 'mypackage' => latest, 'otherpackage' => absent })
   end
+
+  context "when querying instances" do
+    before(:each) do
+      allow(described_class).to receive(:execute).and_return(<<-END.chomp)
+sysmgt.cim.providers:sysmgt.cim.providers.metrics:2.12.1.1: : :B: :Metrics Providers for AIX OS: : : : : : :1:0:/:
+sysmgt.cim.providers:sysmgt.cim.providers.osbase:2.12.1.1: : :C: :Base Providers for AIX OS: : : : : : :1:0:/:
+openssl.base:openssl.base:1.0.2.1800: : :?: :Open Secure Socket Layer: : : : : : :0:0:/:
+END
+    end
+
+    it "should treat installed packages in broken and inconsistent state as absent" do
+      installed_packages = described_class.instances.map { |package| package.properties }
+      expected_packages = [{:name => 'sysmgt.cim.providers.metrics', :ensure => :absent, :status => :broken, :provider => :aix},
+                           {:name => 'sysmgt.cim.providers.osbase', :ensure => '2.12.1.1', :status => :committed, :provider => :aix},
+                           {:name => 'openssl.base', :ensure => :absent, :status => :inconsistent, :provider => :aix}]
+
+      expect(installed_packages).to eql(expected_packages)
+    end
+  end
 end

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

@@ -86,6 +86,83 @@ Version table:
     provider.run_preseed
   end
 
+  describe ".instances" do
+    before do
+      allow(Puppet::Type::Package::ProviderDpkg).to receive(:instances).and_return([resource])
+    end
+
+    context "when package is manual marked" do
+      before do
+        allow(described_class).to receive(:aptmark).with('showmanual').and_return("#{resource.name}\n")
+      end
+
+      it 'sets mark to manual' do
+        expect(resource).to receive(:mark=).with(:manual)
+        described_class.instances
+      end
+    end
+
+    context 'when package is not manual marked ' do
+      before do
+        allow(described_class).to receive(:aptmark).with('showmanual').and_return('')
+      end
+
+      it 'does not set mark to manual' do
+        expect(resource).not_to receive(:mark=).with(:manual)
+        described_class.instances
+      end
+    end
+  end
+
+  describe 'query' do
+    before do
+      allow(provider).to receive(:dpkgquery).and_return("name: #{resource.name}" )
+    end
+
+    context "when package is manual marked" do
+      before do
+        allow(described_class).to receive(:aptmark).with('showmanual').and_return("#{resource.name}\n")
+      end
+
+      it 'sets mark to manual' do
+        result = provider.query
+        expect(result[:mark]).to eql(:manual)
+      end
+    end
+
+    context 'when package is not manual marked ' do
+      before do
+        allow(described_class).to receive(:aptmark).with('showmanual').and_return('')
+      end
+
+      it 'does not set mark to manual' do
+        result = provider.query
+        expect(result[:mark]).to be_nil
+      end
+    end
+  end
+
+  describe 'flush' do
+
+    context "when package is manual marked" do
+      before do
+        provider.mark = :manual
+      end
+
+      it 'does not call aptmark' do
+        expect(provider).not_to receive(:aptmark)
+        provider.flush
+      end
+    end
+
+    context 'when package is not manual marked ' do
+      it 'calls aptmark' do
+        expect(described_class).to receive(:aptmark).with('manual', resource.name)
+        provider.flush
+      end
+    end
+  end
+
   describe "when installing" do
     it "should preseed if a responsefile is provided" do
       resource[:responsefile] = "/my/file"

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

@@ -13,6 +13,7 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
 
     before do
       allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
+      allow(described_class).to receive(:aptmark).with('showmanual').and_return("")
     end
 
     { :absent   => "deinstall ok config-files faff 1.2.3-1\n",

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

@@ -18,7 +18,7 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
     {:failonfail => true, :combine => true, :custom_environment => {}}
   end
 
-  let(:packages) { File.read(my_fixture("dnf-module-list-enabled.txt")) }
+  let(:packages) { File.read(my_fixture("dnf-module-list.txt")) }
   let(:dnf_path) { '/usr/bin/dnf' }
 
   before(:each) { allow(Puppet::Util).to receive(:which).with('/usr/bin/dnf').and_return(dnf_path) }
@@ -81,7 +81,7 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
     end
   end
 
-  describe "when installing a module" do
+  describe "when ensuring a module" do
     let(:name) { 'baz' }
 
     let(:resource) do
@@ -200,14 +200,32 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
         expect(provider.flavor).to eq('minimal')
       end
     end
+
+    context "when disabling a module" do
+
+      it "executed the disable command" do
+        resource[:ensure] = :disabled
+        expect(provider).to receive(:execute).with(array_including('disable'))
+        provider.disable
+      end
+
+      it "does not try to disable if package is already disabled" do
+        allow(described_class).to receive(:command).with(:dnf).and_return(dnf_path)
+        allow(Puppet::Util::Execution).to receive(:execute)
+          .with("/usr/bin/dnf module list -d 0 -e 1")
+          .and_return("baz 1.2 [d][x] common [d], complete  Package Description")
+        resource[:ensure] = :disabled
+        expect(provider).to be_insync(:disabled)
+      end
+    end
   end
 
-  context "parsing the output of module list --enabled" do
+  context "parsing the output of module list" do
     before { allow(described_class).to receive(:command).with(:dnf).and_return(dnf_path) }
 
     it "returns an array of enabled modules" do
       allow(Puppet::Util::Execution).to receive(:execute)
-        .with("/usr/bin/dnf module list --enabled -d 0 -e 1")
+        .with("/usr/bin/dnf module list -d 0 -e 1")
         .and_return(packages)
 
       enabled_packages = described_class.instances.map { |package| package.properties }
@@ -219,7 +237,9 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
                            {name: "postgresql", ensure: "10", flavor: "server", provider: :dnfmodule},
                            {name: "ruby", ensure: "2.5", flavor: :absent, provider: :dnfmodule},
                            {name: "rust-toolset", ensure: "rhel8", flavor: "common", provider: :dnfmodule},
-                           {name: "subversion", ensure: "1.10", flavor: "server", provider: :dnfmodule}]
+                           {name: "subversion", ensure: "1.10", flavor: "server", provider: :dnfmodule},
+                           {name: "swig", ensure: :disabled, flavor: :absent, provider: :dnfmodule},
+                           {name: "virt", ensure: :disabled, flavor: :absent, provider: :dnfmodule}]
 
       expect(enabled_packages).to eql(expected_packages)
     end

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

@@ -32,7 +32,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(bash_installed_io)
 
       installed = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(installed)
+      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg).and_return(installed)
 
       expect(described_class.instances).to eq([installed])
     end
@@ -41,9 +41,9 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(all_installed_io)
 
       bash = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(bash)
+      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg).and_return(bash)
       vim = double('vim')
-      expect(described_class).to receive(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :provider => :dpkg).and_return(vim)
+      expect(described_class).to receive(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :mark => :none, :status => "installed", :provider => :dpkg).and_return(vim)
 
       expect(described_class.instances).to eq([bash, vim])
     end
@@ -107,7 +107,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
         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)
+          expect(provider.query).to eq(:ensure => "2.7.13", :error => "ok", :desired => "install", :name => "python", :mark => :none, :status => "installed", :provider => :dpkg)
         end
 
         it "considers the package absent if the dpkg-query result cannot be interpreted" do
@@ -160,6 +160,20 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
           expect(provider.query[:mark]).to eq(:hold)
         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("2.7.13")
+          expect(provider.query[:mark]).to eq(:hold)
+        end
+
+        it "considers mark status to be none if package is not held" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("install","ok"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("install","ok"), args, query_args)
+          expect(provider.query[:ensure]).to eq("2.7.13")
+          expect(provider.query[:mark]).to eq(:none)
+        end
+
         context "regex check for query search" do
           let(:resource_name) { 'python-email' }
           let(:resource) { instance_double('Puppet::Type::Package') }
@@ -168,10 +182,10 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
             allow(resource).to receive(:[]=)
           end
 
-          it "checks if virtual package regex for query is correctand phisical package is installed" do
+          it "checks if virtual package regex for query is correct and physical 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"})
+            expect(provider.query).to match({:desired => "install", :ensure => "2.7.13", :error => "ok", :name => "python", :mark => :none, :provider => :dpkg, :status => "installed"})
           end
 
           context "regex check with no partial matching" do
@@ -208,7 +222,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       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})
+        expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg})
       end
 
       it "considers the package absent if the dpkg-query result cannot be interpreted" do
@@ -271,6 +285,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
             :error => 'ok',
             :status => 'status',
             :name => resource_name,
+            :mark => :none,
             :ensure => 'ensure',
             :provider => :dpkg,
           }

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

@@ -46,6 +46,8 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
     allow(described_class).to receive(:command).with(:pkginfo).and_return('/bin/pkg_info')
     allow(described_class).to receive(:command).with(:pkgadd).and_return('/bin/pkg_add')
     allow(described_class).to receive(:command).with(:pkgdelete).and_return('/bin/pkg_delete')
+
+    allow(Puppet::FileSystem).to receive(:exist?)
   end
 
   context "#instances" do

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Puppet::Type.type(:package).provider(:pip2) do
+
+  it { is_expected.to be_installable }
+  it { is_expected.to be_uninstallable }
+  it { is_expected.to be_upgradeable }
+  it { is_expected.to be_versionable }
+  it { is_expected.to be_install_options }
+  it { is_expected.to be_targetable }
+
+  it "should inherit most things from pip provider" do
+    expect(described_class < Puppet::Type.type(:package).provider(:pip))
+  end
+
+  it "should use pip2 command" do
+    expect(described_class.cmd).to eq(["pip2"])
+  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/pip_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 osfamilies = { 'windows' => ['pip.exe'], 'other' => ['pip', 'pip-python', 'pip2', 'pip-2'] }
+pip_path_with_spaces = 'C:\Program Files (x86)\Python\Scripts\pip.exe'
 
 describe Puppet::Type.type(:package).provider(:pip) do
 
@@ -102,6 +103,16 @@ describe Puppet::Type.type(:package).provider(:pip) do
         expect(described_class.instances).to eq([])
       end
     end
+
+    context "when pip path location contains spaces" do
+      it "should quote the command before doing execpipe" do
+        allow(described_class).to receive(:which).and_return(pip_path_with_spaces)
+        allow(described_class).to receive(:pip_version).with(pip_path_with_spaces).and_return('8.0.1')
+
+        expect(described_class).to receive(:execpipe).with(["\"#{pip_path_with_spaces}\"", ["freeze"]])
+        described_class.instances
+      end
+    end
   end
 
   context "query" do
@@ -160,15 +171,18 @@ describe Puppet::Type.type(:package).provider(:pip) do
   end
 
   context "latest" do
+    before do
+      allow(described_class).to receive(:pip_version).with(pip_path).and_return(pip_version)
+      allow(described_class).to receive(:which).with('pip').and_return(pip_path)
+      allow(described_class).to receive(:which).with('pip-python').and_return(pip_path)
+      allow(described_class).to receive(:which).with('pip.exe').and_return(pip_path)
+      allow(described_class).to receive(:provider_command).and_return(pip_path)
+      allow(described_class).to receive(:validate_command).with(pip_path)
+    end
+
     context "with pip version < 1.5.4" do
-      before :each do
-        allow(described_class).to receive(:pip_version).with("/fake/bin/pip").and_return('1.0.1')
-        allow(described_class).to receive(:which).with('pip').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip-python').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip.exe').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
-        allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
-      end
+      let(:pip_version) { '1.0.1' }
+      let(:pip_path) { '/fake/bin/pip' }
 
       it "should find a version number for new_pip_package" do
         p = StringIO.new(
@@ -236,19 +250,22 @@ describe Puppet::Type.type(:package).provider(:pip) do
         @resource[:install_options] = ['--index' => 'https://fake.example.com']
         expect(@provider.latest).to eq(nil)
       end
+
+      context "when pip path location contains spaces" do
+        let(:pip_path) { pip_path_with_spaces }
+
+        it "should quote the command before doing execpipe" do
+          expect(Puppet::Util::Execution).to receive(:execpipe).with(array_including("\"#{pip_path}\""))
+          @provider.latest
+        end
+      end
     end
 
     context "with pip version >= 1.5.4" do
       # For Pip 1.5.4 and above, you can get a version list from CLI - which allows for native pip behavior
       # with regards to custom repositories, proxies and the like
-      before :each do
-        allow(described_class).to receive(:pip_version).with("/fake/bin/pip").and_return('1.5.4')
-        allow(described_class).to receive(:which).with('pip').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip-python').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip.exe').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
-        allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
-      end
+      let(:pip_version) { '1.5.4' }
+      let(:pip_path) { '/fake/bin/pip' }
 
       it "should find a version number for real_package" do
         p = StringIO.new(
@@ -296,6 +313,15 @@ describe Puppet::Type.type(:package).provider(:pip) do
         @resource[:install_options] = ['--index' => 'https://fake.example.com']
         expect(@provider.latest).to eq(nil)
       end
+
+      context "when pip path location contains spaces" do
+        let(:pip_path) { pip_path_with_spaces }
+
+        it "should quote the command before doing execpipe" do
+          expect(Puppet::Util::Execution).to receive(:execpipe).with(array_including("\"#{pip_path}\""))
+          @provider.latest
+        end
+      end
     end
   end
 

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

@@ -72,6 +72,11 @@ describe Puppet::Type.type(:package).provider(:portage) do
     expect(described_class).to be_reinstallable
   end
 
+  it "should be the default provider on :osfamily => Gentoo" do
+    expect(Facter).to receive(:value).with(:osfamily).and_return("Gentoo")
+    expect(described_class.default?).to be_truthy
+  end
+
   it 'should support string install options' do
     expect(@provider).to receive(:emerge).with('--foo', '--bar', @resource[:name])