puppet 7.27.0-x86-mingw32 → 8.0.1-x86-mingw32

data/spec/unit/http/service/report_spec.rb

@@ -1,7 +1,10 @@
 require 'spec_helper'
+require 'puppet_spec/network'
 require 'puppet/http'
 
 describe Puppet::HTTP::Service::Report do
+  include PuppetSpec::Network
+
   let(:ssl_context) { Puppet::SSL::SSLContext.new }
   let(:client) { Puppet::HTTP::Client.new(ssl_context: ssl_context) }
   let(:subject) { client.create_session.route_to(:report) }
@@ -64,7 +67,7 @@ describe Puppet::HTTP::Service::Report do
       stub_request(:put, url)
         .with(
           headers: {
-            'Accept'=>'application/json, application/x-msgpack, text/pson',
+            'Accept'=>acceptable_content_types_string,
             'Content-Type'=>'application/json',
            }).
          to_return(status: 200, body: "", headers: {})
@@ -100,18 +103,5 @@ describe Puppet::HTTP::Service::Report do
         expect(err.response.code).to eq(400)
       end
     end
-
-    it 'raises an error if unsuccessful, the server version is < 5, and the current serialization format is not pson' do
-      Puppet[:preferred_serialization_format] = 'json'
-
-      stub_request(:put, url).to_return(status: [400, 'Bad Request'], headers: {'X-Puppet-Version' => '4.2.3' })
-
-      expect {
-        subject.put_report('infinity', report, environment: environment)
-      }.to raise_error do |err|
-        expect(err).to be_an_instance_of(Puppet::HTTP::ProtocolError)
-        expect(err.message).to eq('To submit reports to a server running puppetserver 4.2.3, set preferred_serialization_format to pson')
-      end
-    end
   end
 end

data/spec/unit/http/service_spec.rb

@@ -1,10 +1,13 @@
 require 'spec_helper'
+require 'puppet_spec/network'
 require 'puppet/http'
 require 'puppet/file_serving'
 require 'puppet/file_serving/content'
 require 'puppet/file_serving/metadata'
 
 describe Puppet::HTTP::Service do
+  include PuppetSpec::Network
+
   let(:ssl_context) { Puppet::SSL::SSLContext.new }
   let(:client) { Puppet::HTTP::Client.new(ssl_context: ssl_context) }
   let(:session) { Puppet::HTTP::Session.new(client, []) }
@@ -114,11 +117,7 @@ describe Puppet::HTTP::Service do
   end
 
   it 'returns different mime types for different models' do
-    mimes = if Puppet.features.msgpack?
-              %w[application/json application/x-msgpack text/pson]
-            else
-              %w[application/json text/pson]
-            end
+    mimes = acceptable_content_types
 
     service = TestService.new(client, session, url)
     [
@@ -133,11 +132,6 @@ describe Puppet::HTTP::Service do
     # These are special
     expect(service.mime_types(Puppet::FileServing::Content)).to eq(%w[application/octet-stream])
 
-    catalog_mimes = if Puppet.features.msgpack?
-                      %w[application/vnd.puppet.rich+json application/json application/vnd.puppet.rich+msgpack application/x-msgpack text/pson]
-                    else
-                      %w[application/vnd.puppet.rich+json application/json text/pson]
-                    end
-    expect(service.mime_types(Puppet::Resource::Catalog)).to eq(catalog_mimes)
+    expect(service.mime_types(Puppet::Resource::Catalog)).to eq(acceptable_catalog_content_types)
   end
 end

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -321,7 +321,7 @@ describe Puppet::Resource::Catalog::Compiler do
         expect(facts.timestamp).to eq(time)
       end
 
-      it "accepts PSON facts from older agents" do
+      it "accepts PSON facts from older agents", :if => Puppet.features.pson? do
         request = a_legacy_request_that_contains(facts)
 
         facts = compiler.extract_facts_from_request(request)
@@ -432,9 +432,9 @@ describe Puppet::Resource::Catalog::Compiler do
     before do
       allow(Puppet).to receive(:version).and_return(1)
       set_facts({
-        'fqdn'       => "my.server.com",
-        'ipaddress'  => "my.ip.address",
-        'ipaddress6' => nil
+        'networking.fqdn' => "my.server.com",
+        'networking.ip'   => "my.ip.address",
+        'networking.ip6'  => nil
         })
       @request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
       allow(compiler).to receive(:compile)
@@ -467,16 +467,16 @@ describe Puppet::Resource::Catalog::Compiler do
     before do |example|
       allow(Puppet).to receive(:version).and_return(1)
       set_facts({
-        'fqdn'       => "my.server.com",
-        'ipaddress'  => nil,
+        'networking.fqdn' => "my.server.com",
+        'networking.ip'   => nil,
       })
       if example.metadata[:nil_ipv6]
         set_facts({
-          'ipaddress6' => nil
+          'networking.ip6' => nil
         })
       else
         set_facts({
-          'ipaddress6' => "my.ipv6.address"
+          'networking.ip6' => "my.ipv6.address"
         })
       end
       @request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
@@ -514,9 +514,10 @@ describe Puppet::Resource::Catalog::Compiler do
 
     it "should not add 'pe_serverversion' when FOSS" do
       allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
-      catalog = compiler.find(request)
-
-      expect(catalog.resource('notify', 'PE Version: 2019.2.0')).to be_nil
+      expect {
+        catalog = compiler.find(request)
+        catalog.resource('notify', 'PE Version: 2019.2.0') 
+      }.to raise_error(/Evaluation Error: Unknown variable: 'pe_serverversion'./)
     end
 
     it "should add 'pe_serverversion' when PE" do

data/spec/unit/indirector/face_spec.rb

@@ -11,8 +11,6 @@ describe Puppet::Indirector::Face do
     instance
   end
 
-  it { is_expected.to be_option :extra }
-
   it "should be able to return a list of indirections" do
     expect(Puppet::Indirector::Face.indirections).to be_include("catalog")
   end
@@ -56,14 +54,14 @@ describe Puppet::Indirector::Face do
     end
 
     it "should forward passed options" do
-      expect(subject.indirection).to receive(method).with(:test, *params(method, {'one'=>'1'}))
-      subject.send(method, :test, :extra => {'one'=>'1'})
+      expect(subject.indirection).to receive(method).with(:test, *params(method, {}))
+      subject.send(method, :test, {})
     end
   end
 
   it "should default key to certname for find action" do
-    expect(subject.indirection).to receive(:find).with(Puppet[:certname], {'one'=>'1'})
-    subject.send(:find, :extra => {'one'=>'1'})
+    expect(subject.indirection).to receive(:find).with(Puppet[:certname], {})
+    subject.send(:find, {})
   end
 
   it "should be able to override its indirection name" do

data/spec/unit/indirector/facts/facter_spec.rb

@@ -65,7 +65,7 @@ describe Puppet::Node::Facts::Facter do
     end
 
     it "should return the Facter facts as the values in the Facts instance" do
-      expect(Facter).to receive(:to_hash).and_return("one" => "two")
+      expect(Facter).to receive(:resolve).and_return("one" => "two")
       facts = @facter.find(@request)
       expect(facts.values["one"]).to eq("two")
     end

data/spec/unit/indirector/hiera_spec.rb

@@ -1,9 +1,14 @@
 require 'spec_helper'
 require 'puppet/data_binding'
 require 'puppet/indirector/hiera'
-require 'hiera/backend'
 
-describe Puppet::Indirector::Hiera do
+begin
+  require 'hiera/backend'
+rescue LoadError => e
+  Puppet.warning(_("Unable to load Hiera 3 backend: %{message}") % {message: e.message})
+end
+
+describe Puppet::Indirector::Hiera, :if => Puppet.features.hiera? do
 
   module Testing
     module DataBinding

data/spec/unit/indirector/report/rest_spec.rb

@@ -55,30 +55,4 @@ describe Puppet::Transaction::Report::Rest do
 
     expect(described_class.indirection.save(report)).to eq(["store"])
   end
-
-  describe "when the server major version is less than 5" do
-    it "raises if the save fails and we're not using pson" do
-      Puppet[:preferred_serialization_format] = "json"
-
-      stub_request(:put, uri)
-        .to_return(status: 500,
-                   headers: { 'Content-Type' => 'text/pson', Puppet::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
-
-      expect {
-        described_class.indirection.save(report)
-      }.to raise_error(Puppet::Error, /To submit reports to a server running puppetserver 4.10.1, set preferred_serialization_format to pson/)
-    end
-
-    it "raises with HTTP 500 if the save fails and we're already using pson" do
-      Puppet[:preferred_serialization_format] = "pson"
-
-      stub_request(:put, uri)
-        .to_return(status: 500,
-                   headers: { 'Content-Type' => 'text/pson', Puppet::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
-
-      expect {
-        described_class.indirection.save(report)
-      }.to raise_error(Net::HTTPError, /Error 500 on SERVER/)
-    end
-  end
 end

data/spec/unit/indirector/rest_spec.rb

@@ -123,7 +123,7 @@ describe Puppet::Indirector::REST do
       }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: json error')
     end
 
-    it 'parses the response body as pson and returns the "message"' do
+    it 'parses the response body as pson and returns the "message"', if: Puppet.features.pson? do
       stub_request(
         :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model'
       ).to_return(status: [500, 'Internal Server Error'],

data/spec/unit/module_spec.rb

@@ -773,12 +773,14 @@ describe Puppet::Module do
   end
 
   it "should not have metadata if it has a metadata file and its data is empty" do
+    Puppet[:strict] = :warning
     allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return("")
 
     expect(mymod).not_to be_has_metadata
   end
 
   it "should not have metadata if has a metadata file and its data is invalid" do
+    Puppet[:strict] = :warning
     allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return("This is some invalid json.\n")
     expect(mymod).not_to be_has_metadata
   end
@@ -799,12 +801,6 @@ describe Puppet::Module do
     Puppet::Module.new("yay", "/path", double("env"))
   end
 
-  it "should tolerate failure to parse" do
-    allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return(my_fixture('trailing-comma.json'))
-
-    expect(mymod.has_metadata?).to be_falsey
-  end
-
   describe 'when --strict is warning' do
     before :each do
       Puppet[:strict] = :warning

data/spec/unit/module_tool/tar_spec.rb

@@ -7,7 +7,7 @@ describe Puppet::ModuleTool::Tar do
     { :name => 'Windows', :win => true }
   ].each do |os|
     it "always prefers minitar if it and zlib are present, even with tar available" do
-      allow(Facter).to receive(:value).with('osfamily').and_return(os[:name])
+      allow(Facter).to receive(:value).with('os.family').and_return(os[:name])
       allow(Puppet::Util).to receive(:which).with('tar').and_return('/usr/bin/tar')
       allow(Puppet::Util::Platform).to receive(:windows?).and_return(os[:win])
       allow(Puppet).to receive(:features).and_return(double(:minitar? => true, :zlib? => true))
@@ -17,7 +17,7 @@ describe Puppet::ModuleTool::Tar do
   end
 
   it "falls back to tar when minitar not present and not on Windows" do
-    allow(Facter).to receive(:value).with('osfamily').and_return('ObscureLinuxDistro')
+    allow(Facter).to receive(:value).with('os.family').and_return('ObscureLinuxDistro')
     allow(Puppet::Util).to receive(:which).with('tar').and_return('/usr/bin/tar')
     allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
     allow(Puppet).to receive(:features).and_return(double(:minitar? => false))
@@ -26,7 +26,7 @@ describe Puppet::ModuleTool::Tar do
   end
 
   it "fails when there is no possible implementation" do
-    allow(Facter).to receive(:value).with('osfamily').and_return('Windows')
+    allow(Facter).to receive(:value).with('os.family').and_return('Windows')
     allow(Puppet::Util).to receive(:which).with('tar')
     allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
     allow(Puppet).to receive(:features).and_return(double(:minitar? => false, :zlib? => false))

data/spec/unit/network/formats_spec.rb

@@ -247,7 +247,7 @@ describe "Puppet Network Format" do
     end
   end
 
-  describe "pson" do
+  describe "pson", :if => Puppet.features.pson? do
     let(:pson) { Puppet::Network::FormatHandler.format(:pson) }
 
     it "should include a pson format" do

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

@@ -177,7 +177,8 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
-    it "falls back to the next supported format" do
+    it "falls back to the next supported format", if: Puppet.features.pson? do
+      Puppet[:allow_pson_serialization] = true
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_finds(data, :accept_header => "application/json, text/pson")
@@ -211,11 +212,11 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       }.to raise_error(not_found_error)
     end
 
-    it "should raise FormatError if tries to fallback and pson serialization is not allowed" do
-      Puppet[:allow_pson_serialization] = false
+    it "should raise FormatError if tries to fallback" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_finds(data, :accept_header => "unknown, text/pson")
+      allow(Puppet.features).to receive(:pson?).and_return(true)
       allow(data).to receive(:to_pson).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[pson]: source sequence is illegal/malformed utf-8')
 
       expect {
@@ -237,7 +238,8 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.body).to eq(Puppet::IndirectorTesting.render_multiple(:json, [data]))
     end
 
-    it "falls back to the next supported format" do
+    it "falls back to the next supported format", if: Puppet.features.pson? do
+      Puppet[:allow_pson_serialization] = true
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "application/json, text/pson")
@@ -253,21 +255,19 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     it "raises 406 not acceptable if no formats are accceptable" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
-      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "application/json, text/pson")
-      allow(data).to receive(:to_json).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
-      allow(data).to receive(:to_pson).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[pson]: source sequence is illegal/malformed utf-8')
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "unknown")
 
       expect {
         handler.call(request, response)
       }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError,
-                       %r{No supported formats are acceptable \(Accept: application/json, text/pson\)})
+                       %r{No supported formats are acceptable \(Accept: unknown\)})
     end
 
-    it "raises FormatError if tries to fallback and pson serialization is not allowed" do
-      Puppet[:allow_pson_serialization] = false
+    it "raises FormatError if tries to fallback" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "unknown, text/pson")
+      allow(Puppet.features).to receive(:pson?).and_return(true)
       allow(data).to receive(:to_pson).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[pson]: source sequence is illegal/malformed utf-8')
 
       expect {

data/spec/unit/parser/scope_spec.rb

@@ -162,6 +162,10 @@ describe Puppet::Parser::Scope do
   end
 
   describe "when looking up a variable" do
+    before :each do
+      Puppet[:strict] = :warning
+    end
+
     it "should support :lookupvar and :setvar for backward compatibility" do
       @scope.setvar("var", "yep")
       expect(@scope.lookupvar("var")).to eq("yep")

data/spec/unit/pops/evaluator/arithmetic_ops_spec.rb

@@ -94,6 +94,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     context "on strings requiring boxing to Numeric" do
+      before :each do
+        Puppet[:strict] = :off
+      end
       it "'2' + '2'        ==  4" do
         expect(evaluate(literal('2') + literal('2'))).to eq(4)
       end
@@ -125,6 +128,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       it "'012.3' + '010'  ==  20.3 (not error, floats can start with 0)" do
         expect(evaluate(literal('012.3') + literal('010'))).to eq(20.3)
       end
+
+      it "raises an error when coercing string to numerical by default" do
+        Puppet[:strict] = :error
+        expect { evaluate(literal('2') + literal('2')) }.to raise_error(/Evaluation Error: The string '2' was automatically coerced to the numerical value 2/)
+      end
     end
 
     context 'on binary values' do

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -439,6 +439,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     context "on strings requiring boxing to Numeric" do
+      # turn strict mode off so behavior is not stubbed out
+      before :each do
+        Puppet[:strict] = :off
+      end
       let(:logs) { [] }
       let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
       let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
@@ -851,6 +855,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "[1,2][1, -1.0]"              => "An Array[] cannot use Float where Integer is expected",
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
+        Puppet[:strict] = :off
         expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Regexp.new(Regexp.quote(result)))
       end
     end

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -307,7 +307,7 @@ describe 'loaders' do
     end
 
     it 'all dependent modules are visible' do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson)
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_json)
       allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       loaders = Puppet::Pops::Loaders.new(env)
@@ -338,7 +338,7 @@ describe 'loaders' do
         case_number = from_idx * 3 + called_idx + 1
 
         it "can call #{desc[:called]} from #{desc[:from]} when dependency is present in metadata.json" do
-          allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
+          allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_json)
           allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
           allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
@@ -360,7 +360,7 @@ describe 'loaders' do
         end
 
         it "can not call #{desc[:called]} from #{desc[:from]} if dependency is missing in existing metadata.json" do
-          allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => []).to_pson)
+          allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => []).to_json)
           allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
           allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
@@ -373,7 +373,7 @@ describe 'loaders' do
     end
 
     it "a type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_json)
       allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
@@ -391,7 +391,7 @@ describe 'loaders' do
     end
 
     it "a type can reference a type alias from another module when other module has it declared in init.pp" do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_json)
       allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
@@ -402,7 +402,7 @@ describe 'loaders' do
     end
 
     it "an autoloaded type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_json)
       allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
@@ -412,7 +412,7 @@ describe 'loaders' do
     end
 
     it "an autoloaded type can reference an autoloaded type alias from another module when other module has it declared in init.pp" do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
+      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_json)
       allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])

data/spec/unit/pops/lookup/interpolation_spec.rb

@@ -45,6 +45,18 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     keys.each { |key| expect(adapter).to receive(:track).with(key) }
   end
 
+  context 'when the invocation has a default falsey values' do
+    let(:lookup_invocation) { Lookup::Invocation.new(scope, {}, {'key' => false, 'key2' => nil}, nil) }
+
+    it 'converts boolean false to a "false" string in interpolation' do
+      expect(interpolator.interpolate('%{key}', lookup_invocation, true)).to eq("false")
+    end
+
+    it 'converts nil to an empty string in interpolation' do
+      expect(interpolator.interpolate('%{key2}', lookup_invocation, true)).to eq("")
+    end
+  end
+
   context 'when interpolating nested data' do
     let(:nested_hash) { {'a' => {'aa' => "%{alias('aaa')}"}} }
 

data/spec/unit/pops/serialization/serialization_spec.rb

@@ -298,7 +298,7 @@ module Serialization
 
       it 'nested Expression' do
         expr = parse(<<-CODE)
-          $rootgroup = $osfamily ? {
+          $rootgroup = $os['family'] ? {
               'Solaris'          => 'wheel',
               /(Darwin|FreeBSD)/ => 'wheel',
               default            => 'root',
@@ -435,7 +435,7 @@ module Serialization
 
     it 'can write and read an AST expression' do
       expr = parse(<<-CODE)
-        $rootgroup = $osfamily ? {
+        $rootgroup = $os['family'] ? {
             'Solaris'          => 'wheel',
             /(Darwin|FreeBSD)/ => 'wheel',
             default            => 'root',

data/spec/unit/pops/serialization/to_from_hr_spec.rb

@@ -344,7 +344,7 @@ module Serialization
 
       it 'nested Expression' do
         expr = parse(<<-CODE)
-          $rootgroup = $osfamily ? {
+          $rootgroup = $os['family'] ? {
               'Solaris'          => 'wheel',
               /(Darwin|FreeBSD)/ => 'wheel',
               default            => 'root',
@@ -493,6 +493,10 @@ module Serialization
   end
 
   context 'with rich_data set to false' do
+    before :each do
+      # strict mode off so behavior is not stubbed
+      Puppet[:strict] = :warning
+    end
     let(:to_converter) { ToDataConverter.new(:message_prefix => 'Test Hash', :rich_data => false) }
     let(:logs) { [] }
     let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
@@ -521,6 +525,14 @@ module Serialization
       expect(warnings).to eql([
         "Test Hash contains a hash with a SemanticPuppet::Version key. It will be converted to the String '1.0.0'",
         "Test Hash contains a hash with a SemanticPuppet::Version key. It will be converted to the String '2.0.0'"])
+      end
+
+    it 'A Hash with rich data is not converted and raises error by default' do
+      Puppet[:strict] = :error
+      expect do
+        val = { SemanticPuppet::Version.parse('1.0.0') => 'one', SemanticPuppet::Version.parse('2.0.0') => 'two' }
+        write(val)
+      end.to raise_error(/Evaluation Error: Test Hash contains a hash with a SemanticPuppet::Version key. It will be converted to the String '1.0.0'/)
     end
 
     context 'and symbol_as_string is set to true' do

data/spec/unit/pops/validator/validator_spec.rb

@@ -142,10 +142,9 @@ describe "validating 4x" do
   end
 
   context 'with the default settings for --strict' do
-    it 'produces a warning for duplicate keys in a literal hash' do
+    it 'produces an error for duplicate keys in a literal hash' do
       acceptor = validate(parse('{ a => 1, a => 2 }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
 

data/spec/unit/provider/package/apt_spec.rb

@@ -14,8 +14,8 @@ describe Puppet::Type.type(:package).provider(:apt) do
     resource.provider
   end
 
-  it "should be the default provider on :osfamily => Debian" do
-    expect(Facter).to receive(:value).with(:osfamily).and_return("Debian")
+  it "should be the default provider on 'os.family' => Debian" do
+    expect(Facter).to receive(:value).with('os.family').and_return("Debian")
     expect(described_class.default?).to be_truthy
   end
 

data/spec/unit/provider/package/dnf_spec.rb

@@ -6,40 +6,40 @@ describe Puppet::Type.type(:package).provider(:dnf) do
   context 'default' do
     (19..21).each do |ver|
       it "should not be the default provider on fedora#{ver}" do
-        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("#{ver}")
+        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("#{ver}")
         expect(described_class).to_not be_default
       end
     end
 
     (22..26).each do |ver|
       it "should be the default provider on fedora#{ver}" do
-        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("#{ver}")
+        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("#{ver}")
         expect(described_class).to be_default
       end
     end
 
     it "should not be the default provider on rhel7" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("7")
+      allow(Facter).to receive(:value).with('os.family').and_return(:redhat)
+      allow(Facter).to receive(:value).with('os.name').and_return(:redhat)
+      allow(Facter).to receive(:value).with('os.release.major').and_return("7")
       expect(described_class).to_not be_default
     end
 
     it "should be the default provider on some random future fedora" do
-      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("8675")
+      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("8675")
       expect(described_class).to be_default
     end
 
     it "should be the default provider on rhel8" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("8")
+      allow(Facter).to receive(:value).with('os.family').and_return(:redhat)
+      allow(Facter).to receive(:value).with('os.name').and_return(:redhat)
+      allow(Facter).to receive(:value).with('os.release.major').and_return("8")
       expect(described_class).to be_default
     end
   end