puppet 6.21.1-x64-mingw32 → 7.4.1-x64-mingw32

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'win32/service' if Puppet::Util::Platform.windows?
 
 describe 'Puppet::Type::Service::Provider::Windows',
     :if => Puppet::Util::Platform.windows? && !Puppet::Util::Platform.jruby? do

data/spec/unit/provider_spec.rb

@@ -668,18 +668,6 @@ describe Puppet::Provider do
 
       expect { |b| provider.execpipe("a_command", true, &b) }.to yield_with_args('some output')
     end
-
-    it "delegates instance execfail to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
-
-      provider.new.execfail("a_command", "an exception to raise")
-    end
-
-    it "delegates class execfail to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
-
-      provider.execfail("a_command", "an exception to raise")
-    end
   end
 
   context "mk_resource_methods" do

data/spec/unit/resource/type_collection_spec.rb

@@ -75,18 +75,16 @@ describe Puppet::Resource::TypeCollection do
     end.to raise_error(Puppet::ParseError, /cannot be redefined/)
   end
 
-  it "should remove all nodes, classes, definitions, and applications when cleared" do
+  it "should remove all nodes, classes and definitions when cleared" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
-    loader.add Puppet::Resource::Type.new(:application, "application")
 
     loader.clear
     expect(loader.hostclass("class")).to be_nil
     expect(loader.definition("define")).to be_nil
     expect(loader.node("node")).to be_nil
-    expect(loader.node("application")).to be_nil
   end
 
   describe "when looking up names" do
@@ -155,7 +153,7 @@ describe Puppet::Resource::TypeCollection do
     end
   end
 
-  KINDS = %w{hostclass node definition application}
+  KINDS = %w{hostclass node definition}
   KINDS.each do |data|
     describe "behavior of add for #{data}" do
 
@@ -178,24 +176,6 @@ describe Puppet::Resource::TypeCollection do
       it "should return nil when asked for a #{data} that has not been added" do
         expect(Puppet::Resource::TypeCollection.new(environment).send(data, "foo")).to be_nil
       end
-
-      if data != "node"
-        it "should fail if an application with the same name is added" do
-          loader = Puppet::Resource::TypeCollection.new(environment)
-          instance = Puppet::Resource::Type.new(data, "foo")
-          application = Puppet::Resource::Type.new(:application, "foo")
-          loader.add(instance)
-          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
-        end
-
-        it "should fail if there is an application with the same name" do
-          loader = Puppet::Resource::TypeCollection.new(environment)
-          application = Puppet::Resource::Type.new(:application, "foo")
-          instance = Puppet::Resource::Type.new(data, "foo")
-          loader.add(instance)
-          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
-        end
-      end
     end
   end
 

data/spec/unit/resource_spec.rb

@@ -286,39 +286,6 @@ describe Puppet::Resource do
       Puppet::Parser::AST::Leaf.new(value: value)
     end
 
-    it "should fail when asked to set default values and it is not a parser resource" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("default")})
-      )
-      resource = Puppet::Resource.new("default_param", "name", :environment => environment)
-      expect { resource.set_default_parameters(scope) }.to raise_error(Puppet::DevError)
-    end
-
-    it "should evaluate and set any default values when no value is provided" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("a_default_value")})
-      )
-      resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
-      resource.set_default_parameters(scope)
-      expect(resource["a"]).to eq("a_default_value")
-    end
-
-    it "should skip attributes with no default value" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "no_default_param", :arguments => {"a" => ast_leaf("a_default_value")})
-      )
-      resource = Puppet::Parser::Resource.new("no_default_param", "name", :scope => scope)
-      expect { resource.set_default_parameters(scope) }.not_to raise_error
-    end
-
-    it "should return the list of default parameters set" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("a_default_value")})
-      )
-      resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
-      expect(resource.set_default_parameters(scope)).to eq(["a"])
-    end
-
     describe "when the resource type is :hostclass" do
       let(:environment_name) { "testing env" }
       let(:fact_values) { { 'a' => 1 } }
@@ -402,7 +369,6 @@ describe Puppet::Resource do
 
           it "should use the value provided" do
             expect(Puppet::DataBinding.indirection).not_to receive(:find)
-            expect(resource.set_default_parameters(scope)).to eq([])
             expect(resource[:port]).to eq('8080')
           end
 
@@ -444,28 +410,6 @@ describe Puppet::Resource do
     end
   end
 
-  describe "when validating all required parameters are present" do
-    it "should be able to validate that all required parameters are present" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "required_param", :arguments => {"a" => nil})
-      )
-      expect { Puppet::Resource.new("required_param", "name", :environment => environment).validate_complete }.to raise_error(Puppet::ParseError)
-    end
-
-    it "should not fail when all required parameters are present" do
-      environment.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "no_required_param")
-      )
-      resource = Puppet::Resource.new("no_required_param", "name", :environment => environment)
-      resource["a"] = "meh"
-      expect { resource.validate_complete }.not_to raise_error
-    end
-
-    it "should not validate against builtin types" do
-      expect { Puppet::Resource.new("file", "/bar").validate_complete }.not_to raise_error
-    end
-  end
-
   describe "when referring to a resource with name canonicalization" do
     it "should canonicalize its own name" do
       res = Puppet::Resource.new("file", "/path/")

data/spec/unit/settings/http_extra_headers_spec.rb

@@ -46,18 +46,16 @@ describe Puppet::Settings::HttpExtraHeadersSetting do
     end
 
     describe 'raises an error when' do
-
-      # Ruby 2.3 reports the class of these objects as Fixnum, whereas later ruby versions report them as Integer
       it 'is given an unexpected object type' do
         expect {
           subject.munge(65)
-          }.to raise_error(ArgumentError, /^Expected an Array, String, or Hash, got a (Integer|Fixnum)/)
+          }.to raise_error(ArgumentError, /^Expected an Array, String, or Hash, got a Integer/)
       end
 
       it 'is given an array of unexpected object types' do
         expect {
           subject.munge([65, 82])
-          }.to raise_error(ArgumentError, /^Expected an Array or String, got a (Integer|Fixnum)/)
+          }.to raise_error(ArgumentError, /^Expected an Array or String, got a Integer/)
       end
     end
   end

data/spec/unit/settings/integer_setting_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+require 'puppet/settings'
+require 'puppet/settings/integer_setting'
+
+describe Puppet::Settings::IntegerSetting do
+  let(:setting) { described_class.new(:settings => double('settings'), :desc => "test") }
+
+  it "is of type :integer" do
+    expect(setting.type).to eq(:integer)
+  end
+
+  describe "when munging the setting" do
+    it "returns the same value if given a positive integer" do
+      expect(setting.munge(5)).to eq(5)
+    end
+
+    it "returns the same value if given a negative integer" do
+      expect(setting.munge(-25)).to eq(-25)
+    end
+
+    it "returns an integer if given a valid integer as string" do
+      expect(setting.munge('12')).to eq(12)
+    end
+
+    it "returns an integer if given a valid negative integer as string" do
+      expect(setting.munge('-12')).to eq(-12)
+    end
+
+    it "returns an integer if given a valid positive integer as string" do
+      expect(setting.munge('+12')).to eq(12)
+    end
+
+    it "raises if given an invalid value" do
+      expect { setting.munge('a5') }.to raise_error(Puppet::Settings::ValidationError)
+    end
+
+    it "raises if given nil" do
+      expect { setting.munge(nil) }.to raise_error(Puppet::Settings::ValidationError)
+    end
+  end
+end

data/spec/unit/settings/port_setting_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+require 'puppet/settings'
+require 'puppet/settings/port_setting'
+
+describe Puppet::Settings::PortSetting do
+  let(:setting) { described_class.new(:settings => double('settings'), :desc => "test") }
+
+  it "is of type :port" do
+    expect(setting.type).to eq(:port)
+  end
+
+  describe "when munging the setting" do
+    it "returns the same value if given a valid port as integer" do
+      expect(setting.munge(5)).to eq(5)
+    end
+
+    it "returns an integer if given valid port as string" do
+      expect(setting.munge('12')).to eq(12)
+    end
+
+    it "raises if given a negative port number" do
+      expect { setting.munge('-5') }.to raise_error(Puppet::Settings::ValidationError)
+    end
+
+    it "raises if the port number is too high" do
+      expect { setting.munge(65536) }.to raise_error(Puppet::Settings::ValidationError)
+    end
+
+  end
+end

data/spec/unit/settings/priority_setting_spec.rb

@@ -52,10 +52,10 @@ describe Puppet::Settings::PrioritySetting do
     describe "on a Windows-like platform it", :if => Puppet::Util::Platform.windows? do
       it "parses high, normal, low, and idle priorities" do
         {
-          'high'   => Puppet::Util::Windows::Process::HIGH_PRIORITY_CLASS,
-          'normal' => Puppet::Util::Windows::Process::NORMAL_PRIORITY_CLASS,
-          'low'    => Puppet::Util::Windows::Process::BELOW_NORMAL_PRIORITY_CLASS,
-          'idle'   => Puppet::Util::Windows::Process::IDLE_PRIORITY_CLASS
+          'high'   => Puppet::FFI::Windows::Constants::HIGH_PRIORITY_CLASS,
+          'normal' => Puppet::FFI::Windows::Constants::NORMAL_PRIORITY_CLASS,
+          'low'    => Puppet::FFI::Windows::Constants::BELOW_NORMAL_PRIORITY_CLASS,
+          'idle'   => Puppet::FFI::Windows::Constants::IDLE_PRIORITY_CLASS
         }.each do |value, converted_value|
           expect(setting.munge(value)).to eq(converted_value)
         end

data/spec/unit/settings_spec.rb

@@ -1991,6 +1991,23 @@ describe Puppet::Settings do
     end
   end
 
+  describe 'when settings_catalog is disabled' do
+    let(:settings) { Puppet::Settings.new }
+    before do
+      allow(Puppet).to receive(:[]).with(:settings_catalog).and_return(false)
+    end
+
+    it 'does not compile and apply settings catalog' do
+      expect(settings).not_to receive(:to_catalog)
+      settings.use(:main)
+    end
+
+    it 'logs a message that settings catalog is skipped' do
+      expect(Puppet).to receive(:debug).with('Skipping settings catalog for sections main')
+      settings.use(:main)
+    end
+  end
+
   describe "when dealing with printing configs" do
     before do
       @settings = Puppet::Settings.new

data/spec/unit/ssl/base_spec.rb

@@ -38,9 +38,8 @@ describe Puppet::SSL::Certificate do
 
   describe "when determining a name from a certificate subject" do
     it "should extract only the CN and not any other components" do
-      subject = double('sub')
-      expect(Puppet::Util::SSL).to receive(:cn_from_subject).with(subject).and_return('host.domain.com')
-      expect(@class.name_from_subject(subject)).to eq('host.domain.com')
+      name = OpenSSL::X509::Name.parse('/CN=host.domain.com/L=Portland/ST=Oregon')
+      expect(@class.name_from_subject(name)).to eq('host.domain.com')
     end
   end
 
@@ -89,4 +88,38 @@ describe Puppet::SSL::Certificate do
       }.to raise_error(Puppet::Error, "Unknown signature algorithm 'nonsense'")
     end
   end
+
+  describe "when getting a CN from a subject" do
+    def parse(dn)
+      OpenSSL::X509::Name.parse(dn)
+    end
+
+    def cn_from(subject)
+      @class.name_from_subject(subject)
+    end
+
+    it "should correctly parse a subject containing only a CN" do
+      subj = parse('/CN=foo')
+      expect(cn_from(subj)).to eq('foo')
+    end
+
+    it "should correctly parse a subject containing other components" do
+      subj = parse('/CN=Root CA/OU=Server Operations/O=Example Org')
+      expect(cn_from(subj)).to eq('Root CA')
+    end
+
+    it "should correctly parse a subject containing other components with CN not first" do
+      subj = parse('/emailAddress=foo@bar.com/CN=foo.bar.com/O=Example Org')
+      expect(cn_from(subj)).to eq('foo.bar.com')
+    end
+
+    it "should return nil for a subject with no CN" do
+      subj = parse('/OU=Server Operations/O=Example Org')
+      expect(cn_from(subj)).to eq(nil)
+    end
+
+    it "should return nil for a bare string" do
+      expect(cn_from("/CN=foo")).to eq(nil)
+    end
+  end
 end

data/spec/unit/ssl/certificate_request_spec.rb

@@ -1,23 +1,10 @@
 require 'spec_helper'
 
 require 'puppet/ssl/certificate_request'
-require 'puppet/ssl/key'
 
 describe Puppet::SSL::CertificateRequest do
   let(:request) { described_class.new("myname") }
-  let(:key) {
-    k = Puppet::SSL::Key.new("myname")
-    k.generate
-    k
-  }
-
-  it "should be extended with the Indirector module" do
-    expect(described_class.singleton_class).to be_include(Puppet::Indirector)
-  end
-
-  it "should indirect certificate_request" do
-    expect(described_class.indirection.name).to eq(:certificate_request)
-  end
+  let(:key) { OpenSSL::PKey::RSA.new(Puppet[:keylength]) }
 
   it "should use any provided name as its name" do
     expect(described_class.new("myname").name).to eq("myname")
@@ -83,14 +70,9 @@ describe Puppet::SSL::CertificateRequest do
   end
 
   describe "when generating", :unless => RUBY_PLATFORM == 'java' do
-    it "should use the content of the provided key if the key is a Puppet::SSL::Key instance" do
+    it "should verify the CSR using the public key associated with the private key" do
       request.generate(key)
-      expect(request.content.verify(key.content.public_key)).to be_truthy
-    end
-
-    it "should set the subject to [CN, name]" do
-      request.generate(key)
-      expect(request.content.subject).to eq OpenSSL::X509::Name.new([['CN', key.name]])
+      expect(request.content.verify(key.public_key)).to be_truthy
     end
 
     it "should set the version to 0" do
@@ -101,7 +83,7 @@ describe Puppet::SSL::CertificateRequest do
     it "should set the public key to the provided key's public key" do
       request.generate(key)
       # The openssl bindings do not define equality on keys so we use to_s
-      expect(request.content.public_key.to_s).to eq(key.content.public_key.to_s)
+      expect(request.content.public_key.to_s).to eq(key.public_key.to_s)
     end
 
     context "without subjectAltName / dns_alt_names" do
@@ -295,20 +277,20 @@ describe Puppet::SSL::CertificateRequest do
 
     it "should sign the csr with the provided key" do
       request.generate(key)
-      expect(request.content.verify(key.content.public_key)).to be_truthy
+      expect(request.content.verify(key.public_key)).to be_truthy
     end
 
     it "should verify the generated request using the public key" do
       # Stupid keys don't have a competent == method.
       expect_any_instance_of(OpenSSL::X509::Request).to receive(:verify) do |public_key|
-        public_key.to_s == key.content.public_key.to_s
+        public_key.to_s == key.public_key.to_s
       end.and_return(true)
       request.generate(key)
     end
 
     it "should fail if verification fails" do
       expect_any_instance_of(OpenSSL::X509::Request).to receive(:verify) do |public_key|
-        public_key.to_s == key.content.public_key.to_s
+        public_key.to_s == key.public_key.to_s
       end.and_return(false)
 
       expect do
@@ -334,37 +316,31 @@ describe Puppet::SSL::CertificateRequest do
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA256").and_return(false)
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA1").and_return(true)
       signer = Puppet::SSL::CertificateSigner.new
-      signer.sign(csr, key.content)
-      expect(csr.verify(key.content)).to be_truthy
+      signer.sign(csr, key)
+      expect(csr.verify(key)).to be_truthy
     end
 
-    # Attempts to use SHA512 and SHA384 for signing certificates don't seem to work
-    # So commenting it out till it is sorted out
-    # The problem seems to be with the ability to sign a CSR when using either of
-    # these hash algorithms
-    pending "should use SHA512 to sign the csr when SHA256 and SHA1 aren't available" do
+    it "should use SHA512 to sign the csr when SHA256 and SHA1 aren't available" do
+      key = OpenSSL::PKey::RSA.new(2048)
       csr = OpenSSL::X509::Request.new
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA256").and_return(false)
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA1").and_return(false)
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA512").and_return(true)
       signer = Puppet::SSL::CertificateSigner.new
-      signer.sign(csr, key.content)
-      expect(csr.verify(key.content)).to be_truthy
+      signer.sign(csr, key)
+      expect(csr.verify(key)).to be_truthy
     end
 
-    # Attempts to use SHA512 and SHA384 for signing certificates don't seem to work
-    # So commenting it out till it is sorted out
-    # The problem seems to be with the ability to sign a CSR when using either of
-    # these hash algorithms
-    pending "should use SHA384 to sign the csr when SHA256/SHA1/SHA512 aren't available" do
+    it "should use SHA384 to sign the csr when SHA256/SHA1/SHA512 aren't available" do
+      key = OpenSSL::PKey::RSA.new(2048)
       csr = OpenSSL::X509::Request.new
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA256").and_return(false)
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA1").and_return(false)
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA512").and_return(false)
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA384").and_return(true)
       signer = Puppet::SSL::CertificateSigner.new
-      signer.sign(csr, key.content)
-      expect(csr.verify(key.content)).to be_truthy
+      signer.sign(csr, key)
+      expect(csr.verify(key)).to be_truthy
     end
 
     it "should use SHA224 to sign the csr when SHA256/SHA1/SHA512/SHA384 aren't available" do
@@ -375,8 +351,8 @@ describe Puppet::SSL::CertificateRequest do
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA384").and_return(false)
       expect(OpenSSL::Digest).to receive(:const_defined?).with("SHA224").and_return(true)
       signer = Puppet::SSL::CertificateSigner.new
-      signer.sign(csr, key.content)
-      expect(csr.verify(key.content)).to be_truthy
+      signer.sign(csr, key)
+      expect(csr.verify(key)).to be_truthy
     end
 
     it "should raise an error if neither SHA256/SHA1/SHA512/SHA384/SHA224 are available" do
@@ -390,16 +366,4 @@ describe Puppet::SSL::CertificateRequest do
       }.to raise_error(Puppet::Error)
     end
   end
-
-  it "should save the CSR" do
-    csr = Puppet::SSL::CertificateRequest.new("me")
-    terminus = double('terminus')
-    allow(terminus).to receive(:validate)
-    expect(Puppet::SSL::CertificateRequest.indirection).to receive(:prepare).and_return(terminus)
-    expect(terminus).to receive(:save) do |request|
-      expect(request.instance).to eq(csr)
-      expect(request.key).to eq("me")
-    end
-    Puppet::SSL::CertificateRequest.indirection.save(csr)
-  end
 end