puppet 6.27.0 → 7.0.0

data/spec/integration/network/http_pool_spec.rb

@@ -81,16 +81,6 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
         end
       end
 
-      it "doesn't generate a Puppet::SSL::Host deprecation warning" do
-        server.start_server do |port|
-          http = connection(hostname, port)
-          res = http.get('/')
-          expect(res.code).to eq('200')
-        end
-
-        expect(@logs).to eq([])
-      end
-
       it "detects when the server has closed the connection and reconnects" do
         server.start_server do |port|
           http = connection(hostname, port)
@@ -101,17 +91,13 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
       end
     end
 
-    context "when using single use HTTPS connections" do
-      include_examples 'HTTPS client'
-    end
-
     context "when using persistent HTTPS connections" do
       around :each do |example|
-        pool = Puppet::Network::HTTP::Pool.new(15)
-        Puppet.override(:http_pool => pool) do
+        begin
           example.run
+        ensure
+          Puppet.runtime[:http].close
         end
-        pool.close
       end
 
       include_examples 'HTTPS client'
@@ -183,10 +169,6 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
     end
 
     describe Puppet::Network::HTTP::Connection do
-      it_behaves_like "an HttpPool connection", described_class, true
-    end
-
-    describe Puppet::Network::HTTP::ConnectionAdapter do
       it_behaves_like "an HttpPool connection", described_class, false
     end
   end

data/spec/integration/parser/catalog_spec.rb

@@ -48,44 +48,6 @@ describe "A catalog" do
         expect(resources_in(agent_catalog)).
           to include_in_order(*resources_in_declaration_order)
       end
-
-      it "does not contain unrealized, virtual resources" do
-        virtual_resources = ["Unrealized[unreal]", "Class[Unreal]"]
-
-        master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
-          class unreal { }
-          define unrealized() { }
-
-          class real {
-            @unrealized { "unreal": }
-            @class { "unreal": }
-          }
-
-          include real
-        EOM
-
-        expect(resources_in(master_catalog)).to_not include(*virtual_resources)
-        expect(resources_in(agent_catalog)).to_not include(*virtual_resources)
-      end
-
-      it "does not contain unrealized, exported resources" do
-        exported_resources = ["Unrealized[unreal]", "Class[Unreal]"]
-
-        master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
-          class unreal { }
-          define unrealized() { }
-
-          class real {
-            @@unrealized { "unreal": }
-            @@class { "unreal": }
-          }
-
-          include real
-        EOM
-
-        expect(resources_in(master_catalog)).to_not include(*exported_resources)
-        expect(resources_in(agent_catalog)).to_not include(*exported_resources)
-      end
     end
   end
 

data/spec/integration/parser/node_spec.rb

@@ -117,15 +117,6 @@ describe 'node statements' do
       expect(catalog).to have_resource('Notify[matched]')
     end
 
-    it 'selects a node that is a prefix of the agent name' do
-      Puppet[:strict_hostname_checking] = false
-      catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("node.name.com"))
-      node 'node.name' { notify { matched: } }
-      MANIFEST
-
-      expect(catalog).to have_resource('Notify[matched]')
-    end
-
     it 'does not treat regex symbols as a regex inside a string literal' do
       catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodexname"))
       node 'node.name' { notify { 'not matched': } }

data/spec/integration/parser/pcore_resource_spec.rb

@@ -68,16 +68,6 @@ describe 'when pcore described resources types are in use' do
                 end
               end
             RUBY
-            'cap.rb' => <<-EOF
-            module Puppet
-            Type.newtype(:cap, :is_capability => true) do
-              @doc = "Docs for capability"
-              @isomorphic = false
-              newproperty(:message) do
-                desc "Docs for 'message' property"
-              end
-            end;end
-            EOF
            } } },
         }
       }}})
@@ -126,24 +116,10 @@ describe 'when pcore described resources types are in use' do
         test3 { 'x/y':
           message => 'x/y works'
         }
-        cap { 'c':
-          message => 'c works'
-        }
       MANIFEST
       expect(catalog.resource(:test1, "a")['message']).to eq('a works')
       expect(catalog.resource(:test2, "b")['message']).to eq('b works')
       expect(catalog.resource(:test3, "x/y")['message']).to eq('x/y works')
-      expect(catalog.resource(:cap, "c")['message']).to eq('c works')
-    end
-
-    it 'considers Pcore types to be builtin ' do
-      genface.types
-      catalog = compile_to_catalog(<<-MANIFEST)
-        test1 { 'a':
-          message => 'a works'
-        }
-      MANIFEST
-      expect(catalog.resource(:test1, "a").kind).to eq('compilable_type')
     end
 
     it 'the validity of attribute names are checked' do
@@ -168,20 +144,6 @@ describe 'when pcore described resources types are in use' do
       expect(catalog.resource(:test1, "a")['noop']).to eq(true)
     end
 
-    it 'capability is propagated to the catalog' do
-      genface.types
-      catalog = compile_to_catalog(<<-MANIFEST)
-        test2 { 'r':
-          message => 'a resource'
-        }
-        cap { 'c':
-          message => 'a cap'
-        }
-      MANIFEST
-      expect(catalog.resource(:test2, "r").is_capability?).to eq(false)
-      expect(catalog.resource(:cap, "c").is_capability?).to eq(true)
-    end
-
     it 'a generated type describes if it is isomorphic' do
       generate_and_in_a_compilers_context do |compiler|
         t1 = find_resource_type(compiler.topscope, 'test1')
@@ -191,15 +153,6 @@ describe 'when pcore described resources types are in use' do
       end
     end
 
-    it 'a generated type describes if it is a capability' do
-      generate_and_in_a_compilers_context do |compiler|
-        t1 = find_resource_type(compiler.topscope, 'test1')
-        expect(t1.is_capability?).to be(false)
-        t2 = find_resource_type(compiler.topscope, 'cap')
-        expect(t2.is_capability?).to be(true)
-      end
-    end
-
     it 'a generated type returns parameters defined in pcore' do
       generate_and_in_a_compilers_context do |compiler|
         t1 = find_resource_type(compiler.topscope, 'test1')

data/spec/integration/resource/type_collection_spec.rb

@@ -11,8 +11,12 @@ describe Puppet::Resource::TypeCollection do
       @dir = tmpfile("autoload_testing")
       FileUtils.mkdir_p @dir
 
-      loader = double('loader', load: nil, set_entry: nil)
-      loaders = double('loaders', runtime3_type_loader: loader)
+      loader = Object.new
+      allow(loader).to receive(:load).and_return(nil)
+      allow(loader).to receive(:set_entry)
+
+      loaders = Object.new
+      expect(loaders).to receive(:runtime3_type_loader).at_most(:once).and_return(loader)
       expect(Puppet::Pops::Loaders).to receive(:loaders).at_most(:once).and_return(loaders)
 
       environment = Puppet::Node::Environment.create(:env, [@dir])

data/spec/integration/transaction/report_spec.rb

@@ -48,7 +48,7 @@ describe Puppet::Transaction::Report do
       expect(Puppet::Transaction::Report.indirection).to receive(:save) do |report, x|
         last_run_report = report
         true
-      end.exactly(4)
+      end.twice
 
       Puppet[:report] = true
       Puppet[:noop] = noop1

data/spec/integration/transaction_spec.rb

@@ -61,7 +61,7 @@ describe Puppet::Transaction do
 
     transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
 
-    expect(resource).not_to receive(:retrieve)
+    expect(resource).not_to receive(:evaluate)
 
     transaction.evaluate
   end
@@ -86,7 +86,7 @@ describe Puppet::Transaction do
 
     transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
 
-    expect(resource).not_to receive(:retrieve)
+    expect(resource).not_to receive(:evaluate)
 
     transaction.evaluate
   end
@@ -315,14 +315,16 @@ describe Puppet::Transaction do
         file1 = tmpfile("file1")
         file2 = tmpfile("file2")
 
-        expect(Puppet::FileSystem).to_not be_exist(file2)
-
         exec1 = Puppet::Type.type(:exec).new(
           :name        => "exec1",
           :path        => ENV["PATH"],
           :command     => touch(file1),
         )
 
+        allow(exec1).to receive(:eval_generate).and_return(
+          [ Puppet::Type.type(:notify).new(:name => "eval1_notify") ]
+        )
+
         exec2 = Puppet::Type.type(:exec).new(
           :name        => "exec2",
           :path        => ENV["PATH"],
@@ -330,6 +332,9 @@ describe Puppet::Transaction do
           :refreshonly => true,
           :subscribe   => exec1,
         )
+        allow(exec2).to receive(:eval_generate).and_return(
+          [ Puppet::Type.type(:notify).new(:name => "eval2_notify") ]
+        )
 
         Puppet[:tags] = "exec"
         catalog = mk_catalog(exec1, exec2)

data/spec/integration/type/exec_spec.rb

@@ -7,95 +7,70 @@ describe Puppet::Type.type(:exec), unless: Puppet::Util::Platform.jruby? do
 
   let(:catalog) { Puppet::Resource::Catalog.new }
   let(:path) { tmpfile('exec_provider') }
+  let(:command) { "ruby -e 'File.open(\"#{path}\", \"w\") { |f| f.print \"foo\" }'" }
 
   before :each do
     catalog.host_config = false
   end
 
-  shared_examples_for 'a valid exec resource' do
-    it "should execute the command" do
-      exec = described_class.new :command => command, :path => ENV['PATH']
+  it "should execute the command" do
+    exec = described_class.new :command => command, :path => ENV['PATH']
 
-      catalog.add_resource exec
-      catalog.apply
+    catalog.add_resource exec
+    catalog.apply
 
-      expect(File.read(path)).to eq('foo')
-    end
-
-    it "should not execute the command if onlyif returns non-zero" do
-      exec = described_class.new(
-        :command => command,
-        :onlyif => "ruby -e 'exit 44'",
-        :path => ENV['PATH']
-      )
-
-      catalog.add_resource exec
-      catalog.apply
-
-      expect(Puppet::FileSystem.exist?(path)).to be_falsey
-    end
-
-    it "should execute the command if onlyif returns zero" do
-      exec = described_class.new(
-        :command => command,
-        :onlyif => "ruby -e 'exit 0'",
-        :path => ENV['PATH']
-      )
-
-      catalog.add_resource exec
-      catalog.apply
-
-      expect(File.read(path)).to eq('foo')
-    end
+    expect(File.read(path)).to eq('foo')
+  end
 
-    it "should execute the command if unless returns non-zero" do
-      exec = described_class.new(
-        :command => command,
-        :unless => "ruby -e 'exit 45'",
-        :path => ENV['PATH']
-      )
+  it "should not execute the command if onlyif returns non-zero" do
+    exec = described_class.new(
+      :command => command,
+      :onlyif => "ruby -e 'exit 44'",
+      :path => ENV['PATH']
+    )
 
-      catalog.add_resource exec
-      catalog.apply
+    catalog.add_resource exec
+    catalog.apply
 
-      expect(File.read(path)).to eq('foo')
-    end
+    expect(Puppet::FileSystem.exist?(path)).to be_falsey
+  end
 
-    it "should not execute the command if unless returns zero" do
-      exec = described_class.new(
-        :command => command,
-        :unless => "ruby -e 'exit 0'",
-        :path => ENV['PATH']
-      )
+  it "should execute the command if onlyif returns zero" do
+    exec = described_class.new(
+      :command => command,
+      :onlyif => "ruby -e 'exit 0'",
+      :path => ENV['PATH']
+    )
 
-      catalog.add_resource exec
-      catalog.apply
+    catalog.add_resource exec
+    catalog.apply
 
-      expect(Puppet::FileSystem.exist?(path)).to be_falsey
-    end
+    expect(File.read(path)).to eq('foo')
   end
 
-  context 'when command is a string' do
-    let(:command) { "ruby -e 'File.open(\"#{path}\", \"w\") { |f| f.print \"foo\" }'" }
+  it "should execute the command if unless returns non-zero" do
+    exec = described_class.new(
+      :command => command,
+      :unless => "ruby -e 'exit 45'",
+      :path => ENV['PATH']
+    )
 
-    it_behaves_like 'a valid exec resource'
-  end
+    catalog.add_resource exec
+    catalog.apply
 
-  context 'when command is an array' do
-    let(:command) { ['ruby', '-e', "File.open(\"#{path}\", \"w\") { |f| f.print \"foo\" }"] }
-
-    it_behaves_like 'a valid exec resource'
+    expect(File.read(path)).to eq('foo')
+  end
 
-    context 'when is invalid' do
-      let(:command) { [ "ruby -e 'puts 1'" ] }
+  it "should not execute the command if unless returns zero" do
+    exec = described_class.new(
+      :command => command,
+      :unless => "ruby -e 'exit 0'",
+      :path => ENV['PATH']
+    )
 
-      it 'logs error' do
-        exec = described_class.new :command => command, :path => ENV['PATH']
-        catalog.add_resource exec
-        logs = catalog.apply.report.logs
+    catalog.add_resource exec
+    catalog.apply
 
-        expect(logs[0].message).to eql("Could not find command 'ruby -e 'puts 1''")
-      end
-    end
+    expect(Puppet::FileSystem.exist?(path)).to be_falsey
   end
 end

data/spec/integration/type/file_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'spec_helper'
 
 require 'puppet_spec/files'
@@ -657,9 +658,9 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
     CHECKSUM_TYPES_TO_TRY.each do |checksum_type, checksum|
       describe "when checksum_type is #{checksum_type}" do
-        # FileBucket uses the globally configured default for lookup by digest, which right now is MD5.
+        # FileBucket uses the globally configured default for lookup by digest, which right now is SHA256.
         it_should_behave_like "files are backed up", {:checksum => checksum_type} do
-          let(:filebucket_digest) { Proc.new {|x| Puppet::Util::Checksums.md5(x)} }
+          let(:filebucket_digest) { Proc.new {|x| Puppet::Util::Checksums.sha256(x)} }
         end
       end
     end
@@ -1709,11 +1710,11 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
   describe "when using validate_cmd" do
     test_cmd = '/bin/test'
-    if Puppet.runtime[:facter].value(:osfamily) == 'Debian'
+    if Facter.value(:osfamily) == 'Debian'
       test_cmd = '/usr/bin/test'
     end
 
-    if Puppet.runtime[:facter].value(:operatingsystem) == 'Darwin'
+    if Facter.value(:operatingsystem) == 'Darwin'
       stat_cmd = "stat -f '%Lp'"
     else
       stat_cmd = "stat --format=%a"
@@ -1727,7 +1728,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
                                                #{test_cmd} "644" == "$(#{stat_cmd} ^)"
                                                }))
       report = catalog.apply.report
-      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{md5}/)
+      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{sha256}/)
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_truthy
     end
@@ -1741,7 +1742,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
                                                #{test_cmd} "555" == "$(#{stat_cmd} ^)"
                                                }))
       report = catalog.apply.report
-      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{md5}/)
+      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{sha256}/)
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_truthy
     end

data/spec/integration/type/package_spec.rb

@@ -9,7 +9,7 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
   def provider_name(os)
     case os
     when 'Solaris'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:kernelrelease), '5.11') >= 0
+      if Puppet::Util::Package.versioncmp(Facter.value(:kernelrelease), '5.11') >= 0
         :pkg
       else
         :sun
@@ -21,19 +21,19 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
     when 'Darwin'
       :pkgdmg
     when 'RedHat'
-      if ['2.1', '3', '4'].include?(Puppet.runtime[:facter].value(:lsbdistrelease))
+      if ['2.1', '3', '4'].include?(Facter.value(:lsbdistrelease))
         :up2date
       else
         :yum
       end
     when 'Fedora'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemmajrelease), '22') >= 0
+      if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemmajrelease), '22') >= 0
         :dnf
       else
         :yum
       end
     when 'Suse'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemmajrelease), '10') >= 0
+      if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemmajrelease), '10') >= 0
         :zypper
       else
         :rug
@@ -54,8 +54,8 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
   end
 
   it "should choose the correct provider each platform" do
-    unless default_provider = provider_name(Puppet.runtime[:facter].value(:operatingsystem))
-      pending("No default provider specified in this test for #{Puppet.runtime[:facter].value(:operatingsystem)}")
+    unless default_provider = provider_name(Facter.value(:operatingsystem))
+      pending("No default provider specified in this test for #{Facter.value(:operatingsystem)}")
     end
     expect(Puppet::Type.type(:package).defaultprovider.name).to eq(default_provider)
   end

data/spec/integration/util/rdoc/parser_spec.rb

@@ -91,7 +91,7 @@ end
         File.join(modules_dir, 'a_module', 'lib', 'facter', 'a_fact.rb'),
         <<-EOF
 # The a_fact fact comment
-Puppet.runtime[:facter].add("a_fact") do
+Facter.add("a_fact") do
 end
         EOF
       ],

data/spec/integration/util/windows/adsi_spec.rb

@@ -55,24 +55,6 @@ describe Puppet::Util::Windows::ADSI::User,
       end
     end
   end
-
-  describe '.current_user_name_with_format' do
-    context 'when desired format is NameSamCompatible' do
-      it 'should get the same user name as the current_user_name method but fully qualified' do
-        user_name = Puppet::Util::Windows::ADSI::User.current_user_name
-        fully_qualified_user_name = Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name
-
-        expect(fully_qualified_user_name).to match(/^.+\\#{user_name}$/)
-      end
-
-      it 'should have the same SID as with the current_user_name method' do
-        user_name = Puppet::Util::Windows::ADSI::User.current_user_name
-        fully_qualified_user_name = Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name
-
-        expect(Puppet::Util::Windows::SID.name_to_sid(user_name)).to eq(Puppet::Util::Windows::SID.name_to_sid(fully_qualified_user_name))
-      end
-    end
-  end
 end
 
 describe Puppet::Util::Windows::ADSI::Group,
@@ -175,9 +157,7 @@ describe Puppet::Util::Windows::ADSI::Group,
 
       # touch the native_object member to have it lazily loaded, so COM objects can be stubbed
       admins.native_object
-      without_partial_double_verification do
-        allow(admins.native_object).to receive(:Members).and_return(members)
-      end
+      allow(admins.native_object).to receive(:Members).and_return(members)
 
       # well-known NULL SID
       expect(admins.members[0].sid).to eq('S-1-0-0')