puppet 6.15.0-x86-mingw32 → 6.16.0-x86-mingw32

data/spec/unit/network/http/nocache_pool_spec.rb

@@ -39,4 +39,26 @@ describe Puppet::Network::HTTP::NoCachePool do
   it 'has a close method' do
     Puppet::Network::HTTP::NoCachePool.new.close
   end
+
+  it 'logs a deprecation warning' do
+    http  = double('http', start: nil, finish: nil, started?: true)
+
+    factory = Puppet::Network::HTTP::Factory.new
+    allow(factory).to receive(:create_connection).and_return(http)
+    Puppet::Network::HTTP::NoCachePool.new(factory)
+
+    expect(@logs).to include(an_object_having_attributes(level: :warning, message: /Puppet::Network::HTTP::NoCachePool is deprecated/))
+  end
+
+  it 'omits the warning when deprecations are disabled' do
+    Puppet[:disable_warnings] = 'deprecations'
+
+    http  = double('http', start: nil, finish: nil, started?: true)
+
+    factory = Puppet::Network::HTTP::Factory.new
+    allow(factory).to receive(:create_connection).and_return(http)
+    Puppet::Network::HTTP::NoCachePool.new(factory)
+
+    expect(@logs).to eq([])
+  end
 end

data/spec/unit/network/http_pool_spec.rb

@@ -1,41 +1,65 @@
 require 'spec_helper'
 require 'puppet/network/http_pool'
 
+class Puppet::Network::HttpPool::FooClient
+  def initialize(host, port, options = {})
+    @host = host
+    @port = port
+  end
+  attr_reader :host, :port
+end
+
 describe Puppet::Network::HttpPool do
-  before :each do
-    Puppet::SSL::Key.indirection.terminus_class = :memory
-    Puppet::SSL::CertificateRequest.indirection.terminus_class = :memory
+  include PuppetSpec::Files
+
+  describe "when registering an http client class" do
+    let(:http_impl) { Puppet::Network::HttpPool::FooClient }
+
+    around :each do |example|
+      orig_class = Puppet::Network::HttpPool.http_client_class
+      begin
+        example.run
+      ensure
+        Puppet::Network::HttpPool.http_client_class = orig_class
+      end
+    end
+
+    it "returns instances of the http client class" do
+      Puppet::Network::HttpPool.http_client_class = http_impl
+      http = Puppet::Network::HttpPool.http_instance("me", 54321)
+      expect(http).to be_an_instance_of(http_impl)
+      expect(http.host).to eq('me')
+      expect(http.port).to eq(54321)
+    end
+
+    it "uses the default http client" do
+      expect(Puppet.runtime[:http]).to be_an_instance_of(Puppet::HTTP::Client)
+    end
+
+    it "switches to the external client implementation" do
+      Puppet::Network::HttpPool.http_client_class = http_impl
+
+      expect(Puppet.runtime[:http]).to be_an_instance_of(Puppet::HTTP::ExternalClient)
+    end
+
+    it "always uses an explicitly registered http implementation" do
+      Puppet::Network::HttpPool.http_client_class = http_impl
+
+      new_impl = double('new_http_impl')
+      Puppet.initialize_settings([], true, true, http: new_impl)
+
+      expect(Puppet.runtime[:http]).to eq(new_impl)
+    end
   end
 
   describe "when managing http instances" do
     it "should return an http instance created with the passed host and port" do
       http = Puppet::Network::HttpPool.http_instance("me", 54321)
-      expect(http).to be_an_instance_of Puppet::Network::HTTP::Connection
+      expect(http).to be_a_kind_of Puppet::Network::HTTP::Connection
       expect(http.address).to eq('me')
       expect(http.port).to    eq(54321)
     end
 
-    it "should support using an alternate http client implementation" do
-      begin
-        class FooClient
-          def initialize(host, port, options = {})
-            @host = host
-            @port = port
-          end
-          attr_reader :host, :port
-        end
-
-        orig_class = Puppet::Network::HttpPool.http_client_class
-        Puppet::Network::HttpPool.http_client_class = FooClient
-        http = Puppet::Network::HttpPool.http_instance("me", 54321)
-        expect(http).to be_an_instance_of FooClient
-        expect(http.host).to eq('me')
-        expect(http.port).to eq(54321)
-      ensure
-        Puppet::Network::HttpPool.http_client_class = orig_class
-      end
-    end
-
     it "should enable ssl on the http instance by default" do
       expect(Puppet::Network::HttpPool.http_instance("me", 54321)).to be_use_ssl
     end
@@ -82,53 +106,35 @@ describe Puppet::Network::HttpPool do
     end
 
     describe 'peer verification' do
-      def setup_standard_ssl_configuration
-        ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
-
-        Puppet[:ssl_client_ca_auth] = ca_cert_file
-        allow(Puppet::FileSystem).to receive(:exist?).with(ca_cert_file).and_return(true)
-      end
-
-      def setup_standard_hostcert
-        host_cert_file = File.expand_path('/path/to/ssl/certs/host_cert.pem')
-        allow(Puppet::FileSystem).to receive(:exist?).with(host_cert_file).and_return(true)
-
-        Puppet[:hostcert] = host_cert_file
-      end
-
-      def setup_standard_ssl_host
-        cert = double('cert', :content => 'real_cert')
-        key  = double('key',  :content => 'real_key')
-        host = double('host', :certificate => cert, :key => key, :ssl_store => double('store'))
 
-        allow(Puppet::SSL::Host).to receive(:localhost).and_return(host)
-      end
+      before(:each) do
+        Puppet[:ssldir] = tmpdir('ssl')
+        Puppet.settings.use(:main)
 
-      before do
-        setup_standard_ssl_configuration
-        setup_standard_hostcert
-        setup_standard_ssl_host
+        Puppet[:certname] = 'signed'
+        File.write(Puppet[:localcacert], cert_fixture('ca.pem'))
+        File.write(Puppet[:hostcrl], crl_fixture('crl.pem'))
+        File.write(Puppet[:hostcert], cert_fixture('signed.pem'))
+        File.write(Puppet[:hostprivkey], key_fixture('signed-key.pem'))
       end
 
       it 'enables peer verification by default' do
-        response = Net::HTTPOK.new('1.1', 200, 'body')
+        stub_request(:get, "https://me:54321")
+
         conn = Puppet::Network::HttpPool.http_instance("me", 54321, true)
-        expect(conn).to receive(:execute_request) do |http, _|
+        expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
           expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
-
-          response
         end
 
         conn.get('/')
       end
 
       it 'can disable peer verification' do
-        response = Net::HTTPOK.new('1.1', 200, 'body')
+        stub_request(:get, "https://me:54321")
+
         conn = Puppet::Network::HttpPool.http_instance("me", 54321, true, false)
-        expect(conn).to receive(:execute_request) do |http, _|
+        expect_any_instance_of(Net::HTTP).to receive(:start) do |http|
           expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
-
-          response
         end
 
         conn.get('/')

data/spec/unit/network/http_spec.rb

@@ -4,6 +4,6 @@ require 'puppet/network/http'
 describe Puppet::Network::HTTP do
   it 'defines an http_pool context' do
     pool = Puppet.lookup(:http_pool)
-    expect(pool).to be_a(Puppet::Network::HTTP::NoCachePool)
+    expect(pool).to be_a(Puppet::Network::HTTP::Pool)
   end
 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/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/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])
 

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

@@ -259,7 +259,7 @@ describe Puppet::Type.type(:package).provider(:yum) do
 
   describe 'insync?' do
     context 'when version is not a valid RPM version' do
-      let(:is) { 'a:123' }
+      let(:is) { '>===a:123' }
 
       before do
         resource[:ensure] = is
@@ -269,18 +269,26 @@ describe Puppet::Type.type(:package).provider(:yum) do
         expect(Puppet).to receive(:debug).with("Cannot parse #{is} as a RPM version range")
         provider.insync?(is)
       end
+    end
+
+    context 'with valid semantic versions' do
+      let(:is) { '1:1.2.3.4-5.el4' }
 
-      context 'when requested version equals installed version' do
-        it { expect(provider).to be_insync(is) }
+      it 'returns true if the current version matches the given semantic version' do
+        resource[:ensure] = is
+        expect(provider).to be_insync(is)
       end
 
-      context 'when requested version is different than installed versions' do
-        it { expect(provider).not_to be_insync('999') }
+      it 'returns false if the current version does not match the given semantic version' do
+        resource[:ensure] = '999r'
+        expect(provider).not_to be_insync(is)
       end
-    end
 
-    context 'with valid semantic versions' do
-      let(:is) { '1:1.2.3.4-5.el4' }
+      it 'no debug logs if the current version matches the given semantic version' do
+        resource[:ensure] = is
+        expect(Puppet).not_to receive(:debug)
+        provider.insync?(is)
+      end
 
       it 'returns true if current version matches the greater or equal semantic version in ensure' do
         resource[:ensure] = '<=1:1.2.3.4-5.el4'