puppet 7.28.0-x64-mingw32 → 8.0.1-x64-mingw32

data/spec/unit/provider_spec.rb

@@ -222,20 +222,20 @@ describe Puppet::Provider do
       { :true => false } => false,
       { :false => false } => true,
       { :false => true } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem) } => true,
-      { :operatingsystem => :yayness } => false,
+      { 'os.name' => Puppet.runtime[:facter].value('os.name') } => true,
+      { 'os.name' => :yayness } => false,
       { :nothing => :yayness } => false,
       { :exists => Puppet::Util.which(existing_command) } => true,
       { :exists => "/this/file/does/not/exist" } => false,
       { :true => true, :exists => Puppet::Util.which(existing_command) } => true,
       { :true => true, :exists => "/this/file/does/not/exist" } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
+      { 'os.name' => Puppet.runtime[:facter].value('os.name'),
         :exists => Puppet::Util.which(existing_command) } => true,
-      { :operatingsystem => :yayness,
+      { 'os.name' => :yayness,
         :exists => Puppet::Util.which(existing_command) } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
+      { 'os.name' => Puppet.runtime[:facter].value('os.name'),
         :exists => "/this/file/does/not/exist" } => false,
-      { :operatingsystem => :yayness,
+      { 'os.name' => :yayness,
         :exists => "/this/file/does/not/exist" } => false,
     }.each do |confines, result|
       it "should confine #{confines.inspect} to #{result}" do
@@ -269,32 +269,32 @@ describe Puppet::Provider do
   end
 
   context "default providers" do
-    let :os do Puppet.runtime[:facter].value(:operatingsystem) end
+    let :os do Puppet.runtime[:facter].value('os.name') end
 
     it { is_expected.to respond_to :specificity }
 
     it "should find the default provider" do
       type.provide(:nondefault) {}
-      subject.defaultfor :operatingsystem => os
+      subject.defaultfor 'os.name' => os
       expect(subject.name).to eq(type.defaultprovider.name)
     end
 
     describe "regex matches" do
       it "should match a singular regex" do
-        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("solaris")
+        expect(Facter).to receive(:value).with('os.family').at_least(:once).and_return("solaris")
 
         one = type.provide(:one) do
-          defaultfor :osfamily => /solaris/
+          defaultfor 'os.family' => /solaris/
         end
 
         expect(one).to be_default
       end
 
       it "should not match a non-matching regex " do
-        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("redhat")
+        expect(Facter).to receive(:value).with('os.family').at_least(:once).and_return("redhat")
 
         one = type.provide(:one) do
-          defaultfor :osfamily => /solaris/
+          defaultfor 'os.family' => /solaris/
         end
 
         expect(one).to_not be_default
@@ -302,15 +302,15 @@ describe Puppet::Provider do
 
       it "should allow a mix of regex and string" do
 
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return("fedora")
+        expect(Facter).to receive(:value).with('os.release.major').at_least(:once).and_return("24")
 
         one = type.provide(:one) do
-          defaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => /^2[2-9]$/
+          defaultfor 'os.name' => "fedora", 'os.release.major' => /^2[2-9]$/
         end
 
         two = type.provide(:two) do
-          defaultfor :operatingsystem => /fedora/, :operatingsystemmajrelease => '24'
+          defaultfor 'os.name' => /fedora/, 'os.release.major' => '24'
         end
 
         expect(one).to be_default
@@ -320,21 +320,21 @@ describe Puppet::Provider do
 
     describe "when there are multiple defaultfor's of equal specificity" do
       before :each do
-        subject.defaultfor :operatingsystem => :os1
-        subject.defaultfor :operatingsystem => :os2
+        subject.defaultfor 'os.name' => :os1
+        subject.defaultfor 'os.name' => :os2
       end
 
       let(:alternate) { type.provide(:alternate) {} }
 
       it "should be default for the first defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return(:os1)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for the last defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return(:os2)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
@@ -343,31 +343,31 @@ describe Puppet::Provider do
 
     describe "when there are multiple defaultfor's with different specificity" do
       before :each do
-        subject.defaultfor :operatingsystem => :os1
-        subject.defaultfor :operatingsystem => :os2, :operatingsystemmajrelease => "42"
-        subject.defaultfor :operatingsystem => :os3, :operatingsystemmajrelease => /^4[2-9]$/
+        subject.defaultfor 'os.name' => :os1
+        subject.defaultfor 'os.name' => :os2, 'os.release.major' => "42"
+        subject.defaultfor 'os.name' => :os3, 'os.release.major' => /^4[2-9]$/
       end
 
       let(:alternate) { type.provide(:alternate) {} }
 
       it "should be default for a more specific, but matching, defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return(:os2)
+        expect(Facter).to receive(:value).with('os.release.major').at_least(:once).and_return("42")
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for a more specific, but matching, defaultfor with regex" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os3)
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return(:os3)
+        expect(Facter).to receive(:value).with('os.release.major').at_least(:once).and_return("42")
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for a less specific, but matching, defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
+        expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return(:os1)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
@@ -377,7 +377,7 @@ describe Puppet::Provider do
     it "should consider any true value enough to be default" do
       alternate = type.provide(:alternate) {}
 
-      subject.defaultfor :operatingsystem => [:one, :two, :three, os]
+      subject.defaultfor 'os.name' => [:one, :two, :three, os]
       expect(subject.name).to eq(type.defaultprovider.name)
 
       expect(subject).to be_default
@@ -386,29 +386,29 @@ describe Puppet::Provider do
 
     it "should not be default if the defaultfor doesn't match" do
       expect(subject).not_to be_default
-      subject.defaultfor :operatingsystem => :one
+      subject.defaultfor 'os.name' => :one
       expect(subject).not_to be_default
     end
 
     it "should not be default if the notdefaultfor does match" do
-      expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
-      expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
+      expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return("fedora")
+      expect(Facter).to receive(:value).with('os.release.major').at_least(:once).and_return("24")
 
       one = type.provide(:one) do
-        defaultfor :operatingsystem => "fedora"
-        notdefaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => 24
+        defaultfor 'os.name' => "fedora"
+        notdefaultfor 'os.name' => "fedora", 'os.release.major' => 24
       end
 
       expect(one).not_to be_default
     end
 
     it "should be default if the notdefaultfor doesn't match" do
-      expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
-      expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
+      expect(Facter).to receive(:value).with('os.name').at_least(:once).and_return("fedora")
+      expect(Facter).to receive(:value).with('os.release.major').at_least(:once).and_return("24")
 
       one = type.provide(:one) do
-        defaultfor :operatingsystem => "fedora"
-        notdefaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => 42
+        defaultfor 'os.name' => "fedora"
+        notdefaultfor 'os.name' => "fedora", 'os.release.major' => 42
       end
 
       expect(one).to be_default
@@ -519,18 +519,18 @@ describe Puppet::Provider do
         end
 
         it "with the specification: %{spec}" % { spec: thisspec.join(', ') } do
-          allow(Facter).to receive(:value).with(:osfamily).and_return("redhat")
-          allow(Facter).to receive(:value).with(:operatingsystem).and_return("centos")
-          allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return("27")
+          allow(Facter).to receive(:value).with('os.family').and_return("redhat")
+          allow(Facter).to receive(:value).with('os.name').and_return("centos")
+          allow(Facter).to receive(:value).with('os.release.full').and_return("27")
 
           one = type.provide(:one) do
             if defaultforspec[:one].key?(:defaultfor)
-              defaultfor    :osfamily               => "redhat" if  defaultforspec[:one][:defaultfor]
-              defaultfor    :osfamily               => "ubuntu" if !defaultforspec[:one][:defaultfor]
+              defaultfor    'os.family'               => "redhat" if  defaultforspec[:one][:defaultfor]
+              defaultfor    'os.family'               => "ubuntu" if !defaultforspec[:one][:defaultfor]
             end
             if defaultforspec[:one].key?(:notdefaultfor)
-              notdefaultfor :operatingsystem        => "centos" if  defaultforspec[:one][:notdefaultfor]
-              notdefaultfor :operatingsystem        => "ubuntu" if !defaultforspec[:one][:notdefaultfor]
+              notdefaultfor 'os.name'        => "centos" if  defaultforspec[:one][:notdefaultfor]
+              notdefaultfor 'os.name'        => "ubuntu" if !defaultforspec[:one][:notdefaultfor]
             end
           end
 
@@ -538,14 +538,14 @@ describe Puppet::Provider do
           provider_options[:parent] = one if defaultforspec[:two][:derived] # :two inherits from one, if spec'd
           two = type.provide(:two, provider_options) do
             if defaultforspec[:two].key?(:defaultfor) || defaultforspec[:two].key?(:extradefaultfor)
-              defaultfor    :osfamily               => "redhat" if  defaultforspec[:two][:defaultfor]
-              defaultfor    :osfamily               => "redhat",#   defaultforspec[:two][:extradefaultfor] has two parts
-                            :operatingsystem        => "centos" if  defaultforspec[:two][:extradefaultfor]
-              defaultfor    :osfamily               => "ubuntu" if !defaultforspec[:two][:defaultfor]
+              defaultfor    'os.family'               => "redhat" if  defaultforspec[:two][:defaultfor]
+              defaultfor    'os.family'               => "redhat",#   defaultforspec[:two][:extradefaultfor] has two parts
+                            'os.name'        => "centos" if  defaultforspec[:two][:extradefaultfor]
+              defaultfor    'os.family'               => "ubuntu" if !defaultforspec[:two][:defaultfor]
             end
             if defaultforspec[:two].key?(:notdefaultfor)
-              notdefaultfor :operatingsystemrelease => "27" if  defaultforspec[:two][:notdefaultfor]
-              notdefaultfor :operatingsystemrelease => "99" if !defaultforspec[:two][:notdefaultfor]
+              notdefaultfor 'os.release.full' => "27" if  defaultforspec[:two][:notdefaultfor]
+              notdefaultfor 'os.release.full' => "99" if !defaultforspec[:two][:notdefaultfor]
             end
           end
 

data/spec/unit/reports/store_spec.rb

@@ -15,10 +15,12 @@ describe Puppet::Reports.report(:store) do
     end
 
     let(:report) do
-      if RUBY_VERSION < "3.0"
-        report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
-      else
+      # It's possible to install Psych 5 with Ruby 2.7, so check whether underlying YAML supports
+      # unsafe_load_file. This check can be removed in PUP-11718
+      if YAML.respond_to?(:unsafe_load_file)
         report = YAML.unsafe_load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
+      else
+        report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml'))
       end
       report.extend(described_class)
       report

data/spec/unit/resource/catalog_spec.rb

@@ -13,9 +13,9 @@ describe Puppet::Resource::Catalog, "when compiling" do
     allow(Puppet::Util::Storage).to receive(:store)
   end
 
-  it "should support json, pson, dot, yaml" do
-    # msgpack is optional, so using include instead of eq
-    expect(Puppet::Resource::Catalog.supported_formats).to include(:json, :pson, :dot, :yaml)
+  it "should support json, dot, yaml" do
+    # msgpack and pson are optional, so using include instead of eq
+    expect(Puppet::Resource::Catalog.supported_formats).to include(:json, :dot, :yaml)
   end
 
   # audit only resources are unmanaged
@@ -965,7 +965,8 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
 
     context 'and rich_data is disabled' do
       before(:each) do
-        Puppet[:rich_data] = false
+        Puppet[:rich_data] = false 
+        Puppet[:strict] = :warning # do not want to stub out behavior in tests
       end
 
       let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
@@ -1032,6 +1033,14 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
         expect(message['a']).to eql(nil)
         expect(message['b']).to eql(10)
       end
+
+      it 'should raise an error by default when trying to convert parameter with rich data' do
+        Puppet[:strict] = :error
+        expect {
+          catalog = compile_to_catalog("notify {'foo': message => Timestamp('2016-09-15T08:32:16.123 UTC') }")
+          Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json)) 
+        }.to raise_error(/Evaluation Error: Notify\[foo\]\['message'\] contains a Puppet::Pops::Time::Timestamp value. It will be converted to the String '2016-09-15T08:32:16.123000000 UTC'/)
+      end
     end
   end
 end

data/spec/unit/ssl/certificate_request_spec.rb

@@ -198,7 +198,7 @@ describe Puppet::SSL::CertificateRequest do
 
         expect do
           request.generate(key, :csr_attributes => csr_attributes)
-        end.to raise_error Puppet::Error, /Cannot create CSR with attribute thats\.no\.moon: first num too large/
+        end.to raise_error Puppet::Error, /Cannot create CSR with attribute thats\.no\.moon: /
       end
 
       it "should support old non-DER encoded extensions" do
@@ -271,7 +271,7 @@ describe Puppet::SSL::CertificateRequest do
         exts = {"thats.no.moon" => "death star"}
         expect do
           request.generate(key, :extension_requests => exts)
-        end.to raise_error Puppet::Error, /Cannot create CSR with extension request thats\.no\.moon.*: first num too large/
+        end.to raise_error Puppet::Error, /Cannot create CSR with extension request thats\.no\.moon.*: /
       end
     end
 
@@ -313,6 +313,7 @@ describe Puppet::SSL::CertificateRequest do
 
     it "should use SHA1 to sign the csr when SHA256 isn't available" do
       csr = OpenSSL::X509::Request.new
+      csr.public_key = key.public_key
       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
@@ -323,6 +324,7 @@ describe Puppet::SSL::CertificateRequest 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
+      csr.public_key = key.public_key
       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)
@@ -334,6 +336,7 @@ describe Puppet::SSL::CertificateRequest 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
+      csr.public_key = key.public_key
       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)
@@ -345,6 +348,7 @@ describe Puppet::SSL::CertificateRequest do
 
     it "should use SHA224 to sign the csr when SHA256/SHA1/SHA512/SHA384 aren't available" do
       csr = OpenSSL::X509::Request.new
+      csr.public_key = key.public_key
       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)

data/spec/unit/ssl/ssl_provider_spec.rb

@@ -298,7 +298,8 @@ describe Puppet::SSL::SSLProvider do
       ).to eq(['CN=signed', 'CN=Test CA Subauthority', 'CN=Test CA'])
     end
 
-    it 'raises if client cert signature is invalid', unless: Puppet::Util::Platform.jruby? && RUBY_VERSION.to_f >= 2.6 do
+    it 'raises if client cert signature is invalid' do
+      client_cert.public_key = wrong_key.public_key
       client_cert.sign(wrong_key, OpenSSL::Digest::SHA256.new)
       expect {
         subject.create_context(**config.merge(client_cert: client_cert))
@@ -337,8 +338,9 @@ describe Puppet::SSL::SSLProvider do
       end
     end
 
-    it 'raises if intermediate CA signature is invalid', unless: Puppet::Util::Platform.jruby? && RUBY_VERSION.to_f >= 2.6 do
+    it 'raises if intermediate CA signature is invalid' do
       int = global_cacerts.last
+      int.public_key = wrong_key.public_key if Puppet::Util::Platform.jruby?
       int.sign(wrong_key, OpenSSL::Digest::SHA256.new)
 
       expect {
@@ -459,10 +461,13 @@ describe Puppet::SSL::SSLProvider do
     it "raises if root CA's isCA basic constraint is false", unless: Puppet::Util::Platform.jruby? || OpenSSL::OPENSSL_VERSION_NUMBER < 0x10100000 do
       certs = [cert_fixture('bad-basic-constraints.pem'), cert_fixture('intermediate.pem')]
 
+      # openssl 3 returns 79
+      # define X509_V_ERR_NO_ISSUER_PUBLIC_KEY                 24
+      # define X509_V_ERR_INVALID_CA                           79
       expect {
         subject.create_context(**config.merge(cacerts: certs, crls: [], revocation: false))
       }.to raise_error(Puppet::SSL::CertVerifyError,
-                       "Certificate 'CN=Test CA' failed verification (24): invalid CA certificate")
+                       /Certificate 'CN=Test CA' failed verification \((24|79)\): invalid CA certificate/)
     end
 
     # OpenSSL < 1.1 does not verify basicConstraints
@@ -472,7 +477,7 @@ describe Puppet::SSL::SSLProvider do
       expect {
         subject.create_context(**config.merge(cacerts: certs, crls: [], revocation: false))
       }.to raise_error(Puppet::SSL::CertVerifyError,
-                       "Certificate 'CN=Test CA Subauthority' failed verification (24): invalid CA certificate")
+                       /Certificate 'CN=Test CA Subauthority' failed verification \((24|79)\): invalid CA certificate/)
     end
 
     it 'accepts CA certs in any order' do

data/spec/unit/ssl/state_machine_spec.rb

@@ -30,6 +30,7 @@ describe Puppet::SSL::StateMachine, unless: Puppet::Util::Platform.jruby? do
     Puppet[:daemonize] = false
     Puppet[:ssl_lockfile] = tmpfile('ssllock')
     allow(Kernel).to receive(:sleep)
+    allow_any_instance_of(Puppet::X509::CertProvider).to receive(:crl_last_update).and_return(Time.now + (5 * 60))
   end
 
   def expected_digest(name, content)
@@ -526,12 +527,6 @@ describe Puppet::SSL::StateMachine, unless: Puppet::Util::Platform.jruby? do
       expect(File).to_not exist(Puppet[:hostcrl])
     end
 
-    it 'skips CRL refresh by default' do
-      allow_any_instance_of(Puppet::X509::CertProvider).to receive(:load_crls).and_return(crls)
-
-      state.next_state
-    end
-
     it 'skips CRL refresh if it has not expired' do
       Puppet[:crl_refresh_interval] = '1y'
       Puppet::FileSystem.touch(Puppet[:hostcrl], mtime: Time.now)

data/spec/unit/test/test_helper_spec.rb

@@ -4,14 +4,14 @@ describe "TestHelper" do
   context "#after_each_test" do
     it "restores the original environment" do
       varname = 'test_helper_spec-test_variable'
-      Puppet::Util.set_env(varname, "\u16A0")
+      ENV[varname] = "\u16A0"
 
-      expect(Puppet::Util.get_env(varname)).to eq("\u16A0")
+      expect(ENV[varname]).to eq("\u16A0")
 
       # Prematurely trigger the after_each_test method
       Puppet::Test::TestHelper.after_each_test
 
-      expect(Puppet::Util::get_env(varname)).to be_nil
+      expect(ENV[varname]).to be_nil
     end
   end
-end
+end

data/spec/unit/transaction/report_spec.rb

@@ -138,14 +138,46 @@ describe Puppet::Transaction::Report do
   end
 
   describe "when exclude_unchanged_resources is true" do
+    let(:test_dir) { tmpdir('unchanged_resources') }
+    let(:test_dir2) { tmpdir('unchanged_resources') }
+    let(:test_file) { tmpfile('some_path')}
+    it 'should still list "changed" resource statuses but remove "unchanged"' do
+      transaction = apply_compiled_manifest(<<-END)
+        notify { "hi": } ~>
+        exec { "/bin/this_command_does_not_exist":
+          command => "#{make_absolute('/bin/this_command_does_not_exist')}",
+          refreshonly => true,
+        }
+        file { '#{test_dir}':
+          ensure => directory
+        }
+        file { 'failing_file':
+          path => '#{test_dir2}',
+          ensure => file
+        }
+        file { 'skipped_file':
+          path => '#{test_file}',
+          require => File[failing_file]
+        }
+      END
+      rs = transaction.report.to_data_hash['resource_statuses']
+      expect(rs["Notify[hi]"]['out_of_sync']).to be true
+      expect(rs["Exec[/bin/this_command_does_not_exist]"]['failed_to_restart']).to be true
+      expect(rs["File[failing_file]"]['failed']).to be true
+      expect(rs["File[skipped_file]"]['skipped']).to be true
+      expect(rs).to_not have_key(["File[#{test_dir}]"])
+    end
+  end
+
+  describe"when exclude_unchanged_resources is false" do
     before do
-      Puppet[:exclude_unchanged_resources] = true
+      Puppet[:exclude_unchanged_resources] = false
     end
 
     let(:test_dir) { tmpdir('unchanged_resources') }
     let(:test_dir2) { tmpdir('unchanged_resources') }
     let(:test_file) { tmpfile('some_path')}
-    it 'should still list "changed" resource statuses but remove "unchanged"' do
+    it 'should list all resource statuses' do
       transaction = apply_compiled_manifest(<<-END)
         notify { "hi": } ~>
         exec { "/bin/this_command_does_not_exist":
@@ -169,7 +201,7 @@ describe Puppet::Transaction::Report do
       expect(rs["Exec[/bin/this_command_does_not_exist]"]['failed_to_restart']).to be true
       expect(rs["File[failing_file]"]['failed']).to be true
       expect(rs["File[skipped_file]"]['skipped']).to be true
-      expect(rs).to_not have_key(["File[#{test_dir}]"])
+      expect(rs["File[#{test_dir}]"]['changed']).to be false
     end
   end
 
@@ -578,9 +610,9 @@ Version:
     expect(Puppet::Transaction::Report.default_format).to eq(:json)
   end
 
-  it "supports both json, pson and yaml" do
-    # msgpack is optional, so using include instead of eq
-    expect(Puppet::Transaction::Report.supported_formats).to include(:json, :pson, :yaml)
+  it "supports both json and yaml" do
+    # msgpack and pson are optional, so using include instead of eq
+    expect(Puppet::Transaction::Report.supported_formats).to include(:json, :yaml)
   end
 
   context 'can make a round trip through' do
@@ -590,7 +622,7 @@ Version:
 
     after(:each) { Puppet.pop_context }
 
-    it 'pson' do
+    it 'pson', if: Puppet.features.pson? do
       report = generate_report
 
       tripped = Puppet::Transaction::Report.convert_from(:pson, report.render)

data/spec/unit/type/exec_spec.rb

@@ -252,19 +252,6 @@ RSpec.describe Puppet::Type.type(:exec) do
     expect(dependencies.collect(&:to_s)).to eq([Puppet::Relationship.new(tmp, execer).to_s])
   end
 
-  it "skips autorequire for deferred commands" do
-    foo = make_absolute('/bin/foo')
-    catalog = Puppet::Resource::Catalog.new
-    tmp = Puppet::Type.type(:file).new(:name => foo)
-    execer = Puppet::Type.type(:exec).new(:name => 'test array', :command => Puppet::Pops::Evaluator::DeferredValue.new(nil))
-
-    catalog.add_resource tmp
-    catalog.add_resource execer
-    dependencies = execer.autorequire(catalog)
-
-    expect(dependencies.collect(&:to_s)).to eq([])
-  end
-
   describe "when handling the path parameter" do
     expect = %w{one two three four}
     { "an array"                                      => expect,

data/spec/unit/type/package_spec.rb

@@ -370,9 +370,9 @@ describe Puppet::Type.type(:package) do
   it "should select dnf over yum for dnf supported fedora versions" do
     dnf = Puppet::Type.type(:package).provider(:dnf)
     yum = Puppet::Type.type(:package).provider(:yum)
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("22")
+    allow(Facter).to receive(:value).with('os.family').and_return(:redhat)
+    allow(Facter).to receive(:value).with('os.name').and_return(:fedora)
+    allow(Facter).to receive(:value).with('os.release.major').and_return("22")
 
     expect(dnf.specificity).to be > yum.specificity
   end

data/spec/unit/type/resources_spec.rb

@@ -124,8 +124,8 @@ describe resources do
       context "on #{os}" do
         before :each do
           allow(Facter).to receive(:value).with(:kernel).and_return(os)
-          allow(Facter).to receive(:value).with(:operatingsystem).and_return(os)
-          allow(Facter).to receive(:value).with(:osfamily).and_return(os)
+          allow(Facter).to receive(:value).with('os.name').and_return(os)
+          allow(Facter).to receive(:value).with('os.family').and_return(os)
           allow(Puppet::FileSystem).to receive(:exist?).with('/etc/login.defs').and_return(false)
           @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
           @res.catalog = Puppet::Resource::Catalog.new

data/spec/unit/type_spec.rb

@@ -1142,7 +1142,7 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
 
       before :each do
         type.provide(:default) do
-          defaultfor :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem)
+          defaultfor 'os.name' => Puppet.runtime[:facter].value('os.name')
           mk_resource_methods
           class << self
             attr_accessor :params
@@ -1172,7 +1172,7 @@ describe Puppet::Type, :unless => Puppet::Util::Platform.windows? do
     context "with a default provider" do
       before :each do
         type.provide(:default) do
-          defaultfor :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem)
+          defaultfor 'os.name' => Puppet.runtime[:facter].value('os.name')
           mk_resource_methods
           class << self
             attr_accessor :names

data/spec/unit/util/execution_spec.rb

@@ -29,7 +29,6 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? do
         allow(FFI::WIN32).to receive(:CloseHandle).with(thread_handle)
       else
         allow(Process).to receive(:waitpid2).with(pid, Process::WNOHANG).and_return(nil, [pid, double('child_status', :exitstatus => exitstatus)])
-        allow(Process).to receive(:waitpid2).with(pid, 0).and_return(nil, [pid, double('child_status', :exitstatus => exitstatus)])
         allow(Process).to receive(:waitpid2).with(pid).and_return([pid, double('child_status', :exitstatus => exitstatus)])
       end
     end

data/spec/unit/util/json_lockfile_spec.rb

@@ -16,7 +16,7 @@ describe Puppet::Util::JsonLockfile do
       data = { "foo" => "foofoo", "bar" => "barbar" }
       @lock.lock(data)
 
-      expect(PSON.parse(File.read(@lockfile))).to eq(data)
+      expect(JSON.parse(File.read(@lockfile))).to eq(data)
     end
   end
 

data/spec/unit/util/monkey_patches_spec.rb

@@ -29,21 +29,10 @@ describe Symbol do
 end
 
 describe OpenSSL::SSL::SSLContext do
-  it 'disables SSLv2 via the SSLContext#options bitmask' do
-    expect(subject.options & OpenSSL::SSL::OP_NO_SSLv2).to eq(OpenSSL::SSL::OP_NO_SSLv2)
-  end
-
   it 'disables SSLv3 via the SSLContext#options bitmask' do
     expect(subject.options & OpenSSL::SSL::OP_NO_SSLv3).to eq(OpenSSL::SSL::OP_NO_SSLv3)
   end
 
-  it 'explicitly disable SSLv2 ciphers using the ! prefix so they cannot be re-added' do
-    cipher_str = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
-    if cipher_str
-      expect(cipher_str.split(':')).to include('!SSLv2')
-    end
-  end
-
   it 'does not exclude SSLv3 ciphers shared with TLSv1' do
     cipher_str = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
     if cipher_str
@@ -55,13 +44,6 @@ describe OpenSSL::SSL::SSLContext do
     expect_any_instance_of(described_class).to receive(:set_params)
     subject
   end
-
-  it 'has no ciphers with version SSLv2 enabled' do
-    ciphers = subject.ciphers.select do |name, version, bits, alg_bits|
-      /SSLv2/.match(version)
-    end
-    expect(ciphers).to be_empty
-  end
 end