puppet 7.26.0-x86-mingw32 → 8.0.1-x86-mingw32

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,23 +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.})
-      end
-    end
-  end
-
-  context 'ensure that retrying does not attempt to read the body after closing the connection' do
-    let(:client) { Puppet::HTTP::Client.new(retry_limit: 1) }
-    it 'raises a retry error instead' do
-      response_proc = -> (req, res) {
-        res['Retry-After'] = 1
-        res.status = 503
-      }
-
-      https_server.start_server(response_proc: response_proc) do |port|
-        uri = URI("https://127.0.0.1:#{port}")
-        kwargs = {headers: {'Content-Type' => 'text/plain'}, options: {ssl_context: root_context}}
-        expect{client.post(uri, '', **kwargs)}.to raise_error(Puppet::HTTP::TooManyRetryAfters)
+                         %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'])
@@ -673,6 +676,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

@@ -3,8 +3,46 @@ require 'puppet/settings'
 
 describe "Defaults" do
   describe ".default_diffargs" do
-    it "should be '-u'" do
-      expect(Puppet.default_diffargs).to eq("-u")
+    describe "on AIX" do
+      before(:each) do
+        allow(Facter).to receive(:value).with(:kernel).and_return("AIX")
+      end
+
+      describe "on 5.3" do
+        before(:each) do
+          allow(Facter).to receive(:value).with(:kernelmajversion).and_return("5300")
+        end
+
+        it "should be empty" do
+          expect(Puppet.default_diffargs).to eq("")
+        end
+      end
+
+      [ "",
+        nil,
+        "6300",
+        "7300",
+      ].each do |kernel_version|
+        describe "on kernel version #{kernel_version.inspect}" do
+          before(:each) do
+            allow(Facter).to receive(:value).with(:kernelmajversion).and_return(kernel_version)
+          end
+
+          it "should be '-u'" do
+            expect(Puppet.default_diffargs).to eq("-u")
+          end
+        end
+      end
+    end
+
+    describe "on everything else" do
+      before(:each) do
+        allow(Facter).to receive(:value).with(:kernel).and_return("NOT_AIX")
+      end
+
+      it "should be '-u'" do
+        expect(Puppet.default_diffargs).to eq("-u")
+      end
     end
   end
 
@@ -171,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
 

data/spec/unit/functions/epp_spec.rb

@@ -18,7 +18,13 @@ describe "the epp function" do
       expect(eval_template("all your base <%= $what::is %> to us")).to eq("all your base are belong to us")
     end
 
-    it "get nil accessing a variable that does not exist" do
+    it "gets error accessing a variable that does not exist" do
+      expect { eval_template("<%= $kryptonite == undef %>")}.to raise_error(/Evaluation Error: Unknown variable: 'kryptonite'./)
+    end
+
+    it "get nil accessing a variable that does not exist when strict mode is off" do
+      Puppet[:strict_variables] = false
+      Puppet[:strict] = :warning
       expect(eval_template("<%= $kryptonite == undef %>")).to eq("true")
     end