puppet 7.24.0-universal-darwin → 8.1.0-universal-darwin

data/spec/integration/application/apply_spec.rb

@@ -202,15 +202,19 @@ describe "apply", unless: Puppet::Util::Platform.jruby? do
       compile_to_catalog('include mod', node)
     end
 
-    it 'can apply the catalog' do
-      catalog = compile_to_catalog('include mod', node)
-
-      Puppet[:environment] = env_name
-      apply.command_line.args = ['--catalog', file_containing('manifest', catalog.to_json)]
-
-      expect {
-        apply.run
-      }.to output(%r{Notify\[The Street 23\]/message: defined 'message' as 'The Street 23'}).to_stdout
+    it 'can apply the catalog with no warning' do
+      logs = []
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        catalog = compile_to_catalog('include mod', node)
+        Puppet[:environment] = env_name
+        handler = Puppet::Network::FormatHandler.format(:rich_data_json)
+        apply.command_line.args = ['--catalog', file_containing('manifest', handler.render(catalog))]
+        expect {
+          apply.run
+        }.to output(%r{Notify\[The Street 23\]/message: defined 'message' as 'The Street 23'}).to_stdout
+      end
+      # expected to have no warnings
+      expect(logs.select { |log| log.level == :warning }.map { |log| log.message }).to be_empty
     end
   end
 
@@ -438,6 +442,11 @@ class amod::bad_type {
     end
 
     context 'and the file is not serialized with rich_data' do
+      # do not want to stub out behavior in tests
+      before :each do
+        Puppet[:strict] = :warning
+      end
+
       it 'will notify a string that is the result of Regexp#inspect (from Runtime3xConverter)' do
         catalog = compile_to_catalog(execute, node)
         apply.command_line.args = ['--catalog', file_containing('manifest', catalog.to_json)]
@@ -629,7 +638,7 @@ class amod::bad_type {
           apply.run
         }.to exit_with(0)
          .and output(/Applied catalog/).to_stdout
-         .and output(/Report processor failed: certificate verify failed \[self signed certificate in certificate chain for CN=Unknown CA\]/).to_stderr
+         .and output(/Report processor failed: certificate verify failed \[self.signed certificate in certificate chain for CN=Unknown CA\]/).to_stderr
       end
     end
 
@@ -694,7 +703,9 @@ class amod::bad_type {
        .and output(%r{Notice: /Stage\[main\]/Main/Notify\[deferred4x\]/message: defined 'message' as 'I am deferred'}).to_stdout
     end
 
-    it "fails to apply a deferred function with an unsatified prerequisite" do
+    it "fails to apply a deferred function with an unsatisfied prerequisite" do
+      Puppet[:preprocess_deferred] = true
+
       apply.command_line.args = ['-e', deferred_manifest]
       expect {
         apply.run
@@ -704,8 +715,6 @@ class amod::bad_type {
     end
 
     it "applies a deferred function and its prerequisite in the same run" do
-      Puppet[:preprocess_deferred] = false
-
       apply.command_line.args = ['-e', deferred_manifest]
       expect {
         apply.run
@@ -714,6 +723,7 @@ class amod::bad_type {
     end
 
     it "validates the deferred resource before applying any resources" do
+      Puppet[:preprocess_deferred] = true
       undeferred_file = tmpfile('undeferred')
 
       manifest = <<~END
@@ -738,8 +748,6 @@ class amod::bad_type {
     end
 
     it "evaluates resources before validating the deferred resource" do
-      Puppet[:preprocess_deferred] = false
-
       manifest = <<~END
         notify { 'runs before file': } ->
         file { '#{deferred_file}':

data/spec/integration/configurer_spec.rb

@@ -1,9 +1,11 @@
 require 'spec_helper'
 
+require 'puppet_spec/network'
 require 'puppet/configurer'
 
 describe Puppet::Configurer do
   include PuppetSpec::Files
+  include PuppetSpec::Network
 
   describe "when running" do
     before(:each) do
@@ -117,7 +119,7 @@ describe Puppet::Configurer do
                   "values" => {"test_fact" => 'test value',},
                 }),
               headers: {
-                'Accept'=>'application/json, application/x-msgpack, text/pson',
+                'Accept'=>acceptable_content_types_string,
                 'Content-Type'=>'application/json',
               })
 
@@ -150,7 +152,7 @@ describe Puppet::Configurer do
                 "values" => {"test_fact": "test value"},
               }),
               headers: {
-                'Accept'=>'application/json, application/x-msgpack, text/pson',
+                'Accept'=>acceptable_content_types_string,
                 'Content-Type'=>'application/json',
               }).to_return(status: 200)
 

data/spec/integration/defaults_spec.rb

@@ -137,7 +137,7 @@ describe "Puppet defaults" do
 
     it "path should not add anything" do
       path = "c:\\windows\\system32#{File::PATH_SEPARATOR}c:\\windows"
-      Puppet::Util.withenv( {"PATH" => path }, :windows ) do
+      Puppet::Util.withenv("PATH" => path) do
         Puppet.settings[:path] = "none" # this causes it to ignore the setting
         expect(ENV["PATH"]).to eq(path)
       end
@@ -145,10 +145,10 @@ describe "Puppet defaults" do
 
     it "path should support UTF8 characters" do
       path = "c:\\windows\\system32#{File::PATH_SEPARATOR}c:\\windows#{File::PATH_SEPARATOR}C:\\" + rune_utf8
-      Puppet::Util.withenv( {"PATH" => path }, :windows) do
+      Puppet::Util.withenv("PATH" => path) do
         Puppet.settings[:path] = "none" # this causes it to ignore the setting
 
-        expect(Puppet::Util.get_env('Path')).to eq(path)
+        expect(ENV['Path']).to eq(path)
       end
     end
   end

data/spec/integration/http/client_spec.rb

@@ -53,7 +53,7 @@ describe Puppet::HTTP::Client, unless: Puppet::Util::Platform.jruby? do
         expect {
           client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: alt_context})
         }.to raise_error(Puppet::SSL::CertVerifyError,
-                         %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
+                         %r{certificate verify failed.* .self.signed certificate in certificate chain for CN=Test CA.})
       end
     end
 
@@ -170,7 +170,7 @@ describe Puppet::HTTP::Client, unless: Puppet::Util::Platform.jruby? do
         expect {
           client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: system_context})
         }.to raise_error(Puppet::SSL::CertVerifyError,
-                         %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
+                         %r{certificate verify failed.* .self.signed certificate in certificate chain for CN=Test CA.})
       end
     end
   end

data/spec/integration/network/formats_spec.rb

@@ -43,7 +43,7 @@ describe Puppet::Network::FormatHandler.format(:s) do
   end
 end
 
-describe Puppet::Network::FormatHandler.format(:pson) do
+describe Puppet::Network::FormatHandler.format(:pson), if: Puppet.features.pson? do
   before do
     @pson = Puppet::Network::FormatHandler.format(:pson)
   end

data/spec/integration/network/http/api/indirected_routes_spec.rb

@@ -32,7 +32,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
         it "should find the file metadata with expected checksum" do
           request = a_request_that_finds(Puppet::IndirectorProxy.new("modules/lib/file.rb", "file_metadata"),
-                                         {:accept_header => 'unknown, text/pson'},
+                                         {:accept_header => 'unknown, application/json'},
                                          {:environment => 'production', :checksum_type => checksum_type})
           handler.call(request, response)
           resp = Puppet::Util::Json.load(response.body)
@@ -43,7 +43,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
         it "should search for the file metadata with expected checksum" do
           request = a_request_that_searches(Puppet::IndirectorProxy.new("modules/lib", "file_metadata"),
-                                            {:accept_header => 'unknown, text/pson'},
+                                            {:accept_header => 'unknown, application/json'},
                                             {:environment => 'production', :checksum_type => checksum_type, :recurse => 'yes'})
           handler.call(request, response)
           resp = Puppet::Util::Json.load(response.body)

data/spec/integration/network/http_pool_spec.rb

@@ -77,7 +77,7 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
           expect {
             http.get('/')
           }.to raise_error(Puppet::Error,
-                           %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
+                           %r{certificate verify failed.* .self.signed certificate in certificate chain for CN=Test CA.})
         end
       end
 
@@ -219,7 +219,7 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
         expect {
           http.get('/')
         }.to raise_error(Puppet::Error,
-                         %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
+                         %r{certificate verify failed.* .self.signed certificate in certificate chain for CN=Test CA.})
       end
     end
 

data/spec/integration/node/facts_spec.rb

@@ -30,9 +30,9 @@ describe Puppet::Node::Facts do
     it "should be able to delegate to the :facter terminus" do
       allow(Puppet::Node::Facts.indirection).to receive(:terminus_class).and_return(:facter)
 
-      expect(Facter).to receive(:to_hash).and_return("facter_hash")
+      expect(Facter).to receive(:resolve).and_return({1 => 2})
       facts = Puppet::Node::Facts.new("me")
-      expect(Puppet::Node::Facts).to receive(:new).with("me", "facter_hash").and_return(facts)
+      expect(Puppet::Node::Facts).to receive(:new).with("me", {1 => 2}).and_return(facts)
 
       expect(Puppet::Node::Facts.indirection.find("me")).to equal(facts)
     end

data/spec/integration/parser/compiler_spec.rb

@@ -158,7 +158,7 @@ describe Puppet::Parser::Compiler do
     it 'makes $settings::strict available as string' do
       node = Puppet::Node.new("testing")
       catalog = compile_to_catalog(<<-MANIFEST, node)
-          notify { 'test': message => $settings::strict == 'warning' }
+          notify { 'test': message => $settings::strict == 'error' }
       MANIFEST
       expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
     end
@@ -174,7 +174,7 @@ describe Puppet::Parser::Compiler do
     it 'makes all server settings available as $settings::all_local hash' do
       node = Puppet::Node.new("testing")
       catalog = compile_to_catalog(<<-MANIFEST, node)
-          notify { 'test': message => $settings::all_local['strict'] == 'warning' }
+          notify { 'test': message => $settings::all_local['strict'] == 'error' }
       MANIFEST
       expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
     end
@@ -693,8 +693,19 @@ describe Puppet::Parser::Compiler do
         end.to raise_error(/Illegal variable name/)
       end
 
-      it 'a missing variable as default value becomes undef' do
-        # strict variables not on
+      it 'a missing variable as default causes an evaluation error' do
+        # strict mode on by default for 8.x
+        expect {
+          compile_to_catalog(<<-MANIFEST)
+          class a ($b=$x) { notify {test: message=>"yes ${undef == $b}" } }
+            include a
+          MANIFEST
+        }.to raise_error(/Evaluation Error: Unknown variable: 'x'/)
+      end
+
+      it 'a missing variable as default value becomes undef when strict mode is off' do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
         catalog = compile_to_catalog(<<-MANIFEST)
         class a ($b=$x) { notify {test: message=>"yes ${undef == $b}" } }
           include a

data/spec/integration/parser/conditionals_spec.rb

@@ -68,6 +68,9 @@ describe "Evaluation of Conditionals" do
     end
 
     it "evaluates undefined variables as false" do
+      # strict mode is off so behavior this test is trying to check isn't stubbed out
+      Puppet[:strict_variables] = false
+      Puppet[:strict] = :warning
       catalog = compile_to_catalog(<<-CODE)
       if $undef_var {
       } else {

data/spec/integration/parser/scope_spec.rb

@@ -276,6 +276,9 @@ describe "Two step scoping for variables" do
 
     ['a:.b', '::a::b'].each do |ref|
       it "does not resolve a qualified name on the form #{ref} against top scope" do
+        # strict mode is off so behavior this test is trying to check isn't stubbed out
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
         expect_the_message_not_to_be("from topscope") do <<-"MANIFEST"
               class c {
                 notify { 'something': message => "$#{ref}" }
@@ -297,6 +300,9 @@ describe "Two step scoping for variables" do
 
     ['a:.b', '::a::b'].each do |ref|
       it "does not resolve a qualified name on the form #{ref} against node scope" do
+        # strict mode is off so behavior this test is trying to check isn't stubbed out
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
         expect_the_message_not_to_be("from node") do <<-MANIFEST
               class c {
                 notify { 'something': message => "$a::b" }
@@ -626,8 +632,9 @@ describe "Two step scoping for variables" do
       end
     end
 
-    it "finds nil when the only set variable is in the dynamic scope" do
-      expect_the_message_to_be(nil) do <<-MANIFEST
+    it "raises an evaluation error when the only set variable is in the dynamic scope" do
+      expect {
+        compile_to_catalog(<<-MANIFEST)
             node default {
               include baz
             }
@@ -641,7 +648,7 @@ describe "Two step scoping for variables" do
               include bar
             }
         MANIFEST
-      end
+      }.to raise_error(/Evaluation Error: Unknown variable: 'var'./)
     end
 
     it "ignores the value in the dynamic scope for a defined type" do

data/spec/integration/type/file_spec.rb

@@ -1710,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 Puppet.runtime[:facter].value('os.family') == 'Debian'
       test_cmd = '/usr/bin/test'
     end
 
-    if Puppet.runtime[:facter].value(:operatingsystem) == 'Darwin'
+    if Puppet.runtime[:facter].value('os.name') == 'Darwin'
       stat_cmd = "stat -f '%Lp'"
     else
       stat_cmd = "stat --format=%a"

data/spec/integration/type/package_spec.rb

@@ -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?(Puppet.runtime[:facter].value('os.distro.release.full'))
         :up2date
       else
         :yum
       end
     when 'Fedora'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemmajrelease), '22') >= 0
+      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.major'), '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(Puppet.runtime[:facter].value('os.release.major'), '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(Puppet.runtime[:facter].value('os.name'))
+      pending("No default provider specified in this test for #{Puppet.runtime[:facter].value('os.name')}")
     end
     expect(Puppet::Type.type(:package).defaultprovider.name).to eq(default_provider)
   end

data/spec/integration/util_spec.rb

@@ -96,7 +96,7 @@ describe Puppet::Util do
       Puppet::FileSystem.touch(filepath)
 
       path = [utf8, "c:\\windows\\system32", "c:\\windows"].join(File::PATH_SEPARATOR)
-      Puppet::Util.withenv( { "PATH" => path } , :windows) do
+      Puppet::Util.withenv("PATH" => path) do
         expect(Puppet::Util.which(filename)).to eq(filepath)
       end
     end

data/spec/lib/puppet_spec/network.rb

@@ -33,6 +33,24 @@ module PuppetSpec::Network
     { :environment => "production" }
   end
 
+  def acceptable_content_types
+    types = ['application/json']
+    types << 'application/x-msgpack' if Puppet.features.msgpack?
+    types << 'text/pson' if Puppet.features.pson?
+    types
+  end
+
+  def acceptable_content_types_string
+    acceptable_content_types.join(', ')
+  end
+
+  def acceptable_catalog_content_types
+    types = %w[application/vnd.puppet.rich+json application/json]
+    types.concat(%w[application/vnd.puppet.rich+msgpack application/x-msgpack]) if Puppet.features.msgpack?
+    types << 'text/pson' if Puppet.features.pson?
+    types
+  end
+
   def master_url_prefix
     "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3"
   end

data/spec/shared_examples/rhel_package_provider.rb

@@ -69,7 +69,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
         allow(Puppet::Util).to receive(:which).with("rpm").and_return("/bin/rpm")
         allow(provider).to receive(:which).with("rpm").and_return("/bin/rpm")
         expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).and_return(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most(:once)
-        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('6')
+        allow(Facter).to receive(:value).with('os.release.major').and_return('6')
       end
 
       it "should call #{provider_name} install for :installed" do
@@ -81,7 +81,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
       if provider_name == 'yum'
         context 'on el-5' do
           before(:each) do
-            allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('5')
+            allow(Facter).to receive(:value).with('os.release.major').and_return('5')
           end
 
           it "should catch #{provider_name} install failures when status code is wrong" do

data/spec/unit/application/device_spec.rb

@@ -482,10 +482,10 @@ describe Puppet::Application::Device do
         end
 
         it "retrieves facts" do
-          indirection_fact_values = {"operatingsystem"=>"cisco_ios","clientcert"=>"3750"}
+          indirection_fact_values = {"os"=> {"name" => "cisco_ios"},"clientcert"=>"3750"}
           indirection_facts = Puppet::Node::Facts.new("nil", indirection_fact_values)
           expect(Puppet::Node::Facts.indirection).to receive(:find).with(nil, anything()).and_return(indirection_facts)
-          expect(device).to receive(:puts).with(/name.*3750.*\n.*values.*\n.*operatingsystem.*cisco_ios/)
+          expect(device).to receive(:puts).with(/name.*3750.*\n.*values.*\n.*os.*\n.*name.*cisco_ios/)
           expect { device.main }.to exit_with 0
         end
       end

data/spec/unit/application/lookup_spec.rb

@@ -503,6 +503,9 @@ Searching for "a"
       include PuppetSpec::Files
 
       it "is unaffected by global variables unless '--compile' is used" do
+        # strict mode is off so behavior this test is trying to check isn't stubbed out
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
         lookup.options[:node] = node
         lookup.options[:render_as] = :s
         allow(lookup.command_line).to receive(:args).and_return(['c'])
@@ -665,6 +668,7 @@ Searching for "a"
           expect {
             lookup.run_command
           }.to exit_with(0)
+           .and output(/This is in facts hash/).to_stdout
         end
       end
     end
@@ -673,6 +677,9 @@ Searching for "a"
       let(:node) { Puppet::Node.new("testnode", :facts => facts, :environment => 'puppet_func_provider') }
 
       it "works OK in the absense of '--compile'" do
+        # strict mode is off so behavior this test is trying to check isn't stubbed out
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
         lookup.options[:node] = node
         allow(lookup.command_line).to receive(:args).and_return(['c'])
         lookup.options[:render_as] = :s

data/spec/unit/application/resource_spec.rb

@@ -129,22 +129,24 @@ describe Puppet::Application::Resource do
   end
 
   describe "when printing output" do
-    it "should not emit puppet class tags when printing yaml" do
-      Puppet::Type.newtype(:stringify) do
-        ensurable
-        newparam(:name, isnamevar: true)
-        newproperty(:string)
-      end
+    Puppet::Type.newtype(:stringify) do
+      ensurable
+      newparam(:name, isnamevar: true)
+      newproperty(:string)
+    end
 
-      Puppet::Type.type(:stringify).provide(:stringify) do
-        def exists?
-          true
-        end
+    Puppet::Type.type(:stringify).provide(:stringify) do
+      def exists?
+        true
+      end
 
-        def string
-          Puppet::Util::Execution::ProcessOutput.new('test', 0)
-        end
+      def string
+        Puppet::Util::Execution::ProcessOutput.new('test', 0)
       end
+    end
+    
+    it "should not emit puppet class tags when printing yaml when strict mode is off" do
+      Puppet[:strict] = :warning
 
       @resource_app.options[:to_yaml] = true
       allow(@resource_app.command_line).to receive(:args).and_return(['stringify', 'hello', 'ensure=present', 'string=asd'])
@@ -158,6 +160,13 @@ describe Puppet::Application::Resource do
       expect { @resource_app.main }.not_to raise_error
     end
 
+    it "should raise an error when printing yaml by default" do
+      @resource_app.options[:to_yaml] = true
+      allow(@resource_app.command_line).to receive(:args).and_return(['stringify', 'hello', 'ensure=present', 'string=asd'])
+      expect { @resource_app.main }.to raise_error( Puppet::PreformattedError,
+        /Stringify\[hello\]\['string'\] contains a Puppet::Util::Execution::ProcessOutput value. It will be converted to the String 'test'/)
+    end
+
     it "should ensure all values to be printed are in the external encoding" do
       resources = [
         Puppet::Type.type(:user).new(:name => "\u2603".force_encoding(Encoding::UTF_8)).to_resource,

data/spec/unit/configurer/fact_handler_spec.rb

@@ -79,7 +79,7 @@ describe Puppet::Configurer::FactHandler do
       { :hash => { 'afact' => "A\u06FF\u16A0\u{2070E}" }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'A%DB%BF%E1%9A%A0%F0%A0%9C%8E' + '%22%7D' },
     ]
 
-    context "as pson" do
+    context "as pson", if: Puppet.features.pson? do
       before :each do
         Puppet[:preferred_serialization_format] = 'pson'
       end

data/spec/unit/confine_spec.rb

@@ -84,16 +84,16 @@ describe Puppet::Confine do
   describe "when requiring" do
     it "does not cache failed requires when always_retry_plugins is true" do
       Puppet[:always_retry_plugins] = true
-      expect(Puppet::Confine).to receive(:require).with('puppet/confine/osfamily').twice.and_raise(LoadError)
-      Puppet::Confine.test(:osfamily)
-      Puppet::Confine.test(:osfamily)
+      expect(Puppet::Confine).to receive(:require).with('puppet/confine/os.family').twice.and_raise(LoadError)
+      Puppet::Confine.test('os.family')
+      Puppet::Confine.test('os.family')
     end
 
     it "caches failed requires when always_retry_plugins is false" do
       Puppet[:always_retry_plugins] = false
-      expect(Puppet::Confine).to receive(:require).with('puppet/confine/osfamily').once.and_raise(LoadError)
-      Puppet::Confine.test(:osfamily)
-      Puppet::Confine.test(:osfamily)
+      expect(Puppet::Confine).to receive(:require).with('puppet/confine/os.family').once.and_raise(LoadError)
+      Puppet::Confine.test('os.family')
+      Puppet::Confine.test('os.family')
     end
   end
 end

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -35,6 +35,7 @@ describe "when using a hiera data provider" do
     node = Puppet::Node.new("testnode", :facts => facts, :environment => environment)
     compiler = Puppet::Parser::Compiler.new(node)
     compiler.topscope['domain'] = 'example.com'
+    compiler.topscope['my_fact'] = 'server3'
     block_given? ? compiler.compile { |catalog| yield(compiler); catalog } : compiler.compile
   end
 
@@ -164,6 +165,7 @@ describe "when using a hiera data provider" do
     expect(extract_notifications(compiler.compile)).to include('server2')
 
     compiler = Puppet::Parser::Compiler.new(node)
+    compiler.topscope['my_fact'] = 'server3'
     expect(extract_notifications(compiler.compile)).to include('In name.yaml')
   end
 

data/spec/unit/defaults_spec.rb

@@ -209,4 +209,12 @@ describe "Defaults" do
       expect(Puppet.default_cadir).to eq(cadir)
     end
   end
+
+  describe "#preferred_serialization_format" do
+    it 'raises if PSON is not available', unless: Puppet.features.pson? do
+      expect {
+        Puppet.settings[:preferred_serialization_format] = "pson"
+      }.to raise_error(Puppet::Settings::ValidationError, "The 'puppet-pson' gem must be installed to use the PSON serialization format.")
+    end
+  end
 end

data/spec/unit/external/pson_spec.rb

@@ -1,9 +1,7 @@
 # Encoding: UTF-8
 require 'spec_helper'
 
-require 'puppet/external/pson/common'
-
-describe PSON do
+describe 'PSON', if: Puppet.features.pson? do
   {
     'foo' => '"foo"',
     1 => '1',

data/spec/unit/face/epp_face_spec.rb

@@ -311,8 +311,8 @@ describe Puppet::Face[:epp, :current] do
 
     it "facts can be overridden" do
       expect(eppface.render({
-        :facts => {'operatingsystem' => 'Merwin'},
-        :e     => '<%= $facts[operatingsystem] %>', 
+        :facts => {'os' => {'name' => 'Merwin'} },
+        :e     => '<%= $facts[os][name] %>',
       })).to eql("Merwin")
     end
 

data/spec/unit/file_bucket/dipper_spec.rb

@@ -104,8 +104,8 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
           # Diff without the context
           # Lines we need to see match 'Content' instead of trimming diff output filter out
           # surrounding noise...or hard code the check values
-          if Puppet.runtime[:facter].value(:osfamily) == 'Solaris' &&
-            Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemrelease), '11.0') >= 0
+          if Puppet.runtime[:facter].value('os.family') == 'Solaris' &&
+            Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.full'), '11.0') >= 0
             # Use gdiff on Solaris
             diff12 = Puppet::Util::Execution.execute("gdiff -uN #{file1} #{file2}| grep Content")
             diff21 = Puppet::Util::Execution.execute("gdiff -uN #{file2} #{file1}| grep Content")

data/spec/unit/file_serving/metadata_spec.rb

@@ -21,9 +21,9 @@ describe Puppet::FileServing::Metadata do
     expect(Puppet::FileServing::Metadata.default_format).to eq(:json)
   end
 
-  it "should support json, pson, yaml" do
-    # msgpack is optional, so using include instead of eq
-    expect(Puppet::FileServing::Metadata.supported_formats).to include(:json, :pson, :yaml)
+  it "should support json and yaml" do
+    # msgpack and pson are optional, so using include instead of eq
+    expect(Puppet::FileServing::Metadata.supported_formats).to include(:json, :yaml)
   end
 
   it "should support deserialization" do

data/spec/unit/file_serving/mount/file_spec.rb

@@ -3,8 +3,8 @@ require 'puppet/file_serving/mount/file'
 
 module FileServingMountTesting
   def stub_facter(hostname)
-    allow(Facter).to receive(:value).with("hostname").and_return(hostname.sub(/\..+/, ''))
-    allow(Facter).to receive(:value).with("domain").and_return(hostname.sub(/^[^.]+\./, ''))
+    allow(Facter).to receive(:value).with("networking.hostname").and_return(hostname.sub(/\..+/, ''))
+    allow(Facter).to receive(:value).with("networking.domain").and_return(hostname.sub(/^[^.]+\./, ''))
   end
 end