puppet 7.10.0 → 7.13.1

data/spec/unit/puppet_spec.rb

@@ -91,12 +91,20 @@ describe Puppet do
       expect(Puppet.runtime[:http]).to be_an_instance_of(Puppet::HTTP::Client)
     end
 
-    it 'allows an implementation to be registered' do
-      impl = double('http')
-      Puppet.initialize_settings([], true, true, http: impl)
+    it 'allows a http implementation to be registered' do
+      http_impl = double('http')
+      Puppet.initialize_settings([], true, true, http: http_impl)
 
 
-      expect(Puppet.runtime[:http]).to eq(impl)
+      expect(Puppet.runtime[:http]).to eq(http_impl)
+    end
+
+    it 'allows a facter implementation to be registered' do
+      facter_impl = double('facter')
+      Puppet.initialize_settings([], true, true, facter: facter_impl)
+
+
+      expect(Puppet.runtime[:facter]).to eq(facter_impl)
     end
   end
 

data/spec/unit/resource/catalog_spec.rb

@@ -104,7 +104,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
   it "should include the current catalog_format" do
     catalog = Puppet::Resource::Catalog.new("host")
-    expect(catalog.catalog_format).to eq(1)
+    expect(catalog.catalog_format).to eq(2)
   end
 
   describe "when compiling" do
@@ -178,6 +178,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @original.add_edge(@middle, @bottom)
       @original.add_edge(@bottom, @bottomobject)
 
+      @original.catalog_format = 1
       @catalog = @original.to_ral
     end
 
@@ -190,6 +191,18 @@ describe Puppet::Resource::Catalog, "when compiling" do
       end
     end
 
+    it "should raise if an unknown resource is being converted" do
+      @new_res = Puppet::Resource.new "Unknown", "type", :kind => 'compilable_type'
+      @resource_array = [@new_res]
+
+      @original.add_resource(*@resource_array)
+      @original.add_edge(@bottomobject, @new_res)
+
+      @original.catalog_format = 2
+
+      expect { @original.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
+    end
+
     it "should copy the tag list to the new catalog" do
       expect(@catalog.tags.sort).to eq(@original.tags.sort)
     end

data/spec/unit/resource_spec.rb

@@ -638,19 +638,68 @@ describe Puppet::Resource do
     it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
       resource = Puppet::Resource.new("file", basepath+"/my/file")
       result = resource.to_ral
+
       expect(result).to be_instance_of(Puppet::Type.type(:file))
       expect(result[:path]).to eq(basepath+"/my/file")
     end
 
-    it "should convert to a component instance if the resource type is not of a builtin type" do
+    it "should convert to a component instance if the resource is not a compilable_type" do
       resource = Puppet::Resource.new("foobar", "somename")
       result = resource.to_ral
 
       expect(result).to be_instance_of(Puppet::Type.type(:component))
       expect(result.title).to eq("Foobar[somename]")
     end
-  end
 
+    it "should convert to a component instance if the resource is a class" do
+      resource = Puppet::Resource.new("Class", "somename")
+      result = resource.to_ral
+
+      expect(result).to be_instance_of(Puppet::Type.type(:component))
+      expect(result.title).to eq("Class[Somename]")
+    end
+
+    it "should convert to component when the resource is a defined_type" do
+      resource = Puppet::Resource.new("Unknown", "type", :kind => 'defined_type')
+
+      result = resource.to_ral
+      expect(result).to be_instance_of(Puppet::Type.type(:component))
+    end
+
+    it "should raise if a resource type is a compilable_type and it wasn't found" do
+      resource = Puppet::Resource.new("Unknown", "type", :kind => 'compilable_type')
+
+      expect { resource.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
+    end
+
+    it "should use the old behaviour when the catalog_format is equal to 1" do
+      resource = Puppet::Resource.new("Unknown", "type")
+      catalog = Puppet::Resource::Catalog.new("mynode")
+
+      resource.catalog = catalog
+      resource.catalog.catalog_format = 1
+
+      result = resource.to_ral
+      expect(result).to be_instance_of(Puppet::Type.type(:component))
+    end
+
+    it "should use the new behaviour and fail when the catalog_format is greater than 1" do
+      resource = Puppet::Resource.new("Unknown", "type", :kind => 'compilable_type')
+      catalog = Puppet::Resource::Catalog.new("mynode")
+
+      resource.catalog = catalog
+      resource.catalog.catalog_format = 2
+
+      expect { resource.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
+    end
+
+    it "should use the resource type when the resource doesn't respond to kind and the resource type can be found" do
+      resource = Puppet::Resource.new("file", basepath+"/my/file")
+
+      result = resource.to_ral
+      expect(result).to be_instance_of(Puppet::Type.type(:file))
+    end
+  end
   describe "when converting to puppet code" do
     before do
       @resource = Puppet::Resource.new("one::two", "/my/file",
@@ -766,6 +815,13 @@ describe Puppet::Resource do
       expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).line).to eq(50)
     end
 
+    it "should include the kind if one is set" do
+      resource = Puppet::Resource.new("File", "/foo")
+      resource.kind = 'im_a_file'
+
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).kind).to eq('im_a_file')
+    end
+
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true

data/spec/unit/settings/file_setting_spec.rb

@@ -125,9 +125,10 @@ describe Puppet::Settings::FileSetting do
   describe "when being converted to a resource" do
     before do
       @basepath = make_absolute("/somepath")
+      allow(Puppet::FileSystem).to receive(:exist?).and_call_original
+      allow(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(true)
       @settings = double('settings')
       @file = Puppet::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :myfile, :section => "mysect")
-      allow(@file).to receive(:create_files?).and_return(true)
       allow(@settings).to receive(:value).with(:myfile, nil, false).and_return(@basepath)
     end
 
@@ -135,18 +136,19 @@ describe Puppet::Settings::FileSetting do
       expect(@file.type).to eq(:file)
     end
 
-    it "should skip non-existent files if 'create_files' is not enabled" do
-      expect(@file).to receive(:create_files?).and_return(false)
+    it "skips non-existent files" do
       expect(@file).to receive(:type).and_return(:file)
       expect(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(false)
       expect(@file.to_resource).to be_nil
     end
 
-    it "should manage existent files even if 'create_files' is not enabled" do
-      expect(@file).to receive(:create_files?).and_return(false)
+    it "manages existing files" do
       expect(@file).to receive(:type).and_return(:file)
-      allow(Puppet::FileSystem).to receive(:exist?)
-      expect(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(true)
+      expect(@file.to_resource).to be_instance_of(Puppet::Resource)
+    end
+
+    it "always manages directories" do
+      expect(@file).to receive(:type).and_return(:directory)
       expect(@file.to_resource).to be_instance_of(Puppet::Resource)
     end
 
@@ -177,6 +179,7 @@ describe Puppet::Settings::FileSetting do
     it "should fully qualified returned files if necessary (#795)" do
       allow(@settings).to receive(:value).with(:myfile, nil, false).and_return("myfile")
       path = File.expand_path('myfile')
+      allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
       expect(@file.to_resource.title).to eq(path)
     end
 

data/spec/unit/transaction/persistence_spec.rb

@@ -138,6 +138,57 @@ describe Puppet::Transaction::Persistence do
         persistence = Puppet::Transaction::Persistence.new
         expect(persistence.load.dig("File[/tmp/audit]", "parameters", "mtime", "system_value")).to contain_exactly(be_a(Time))
       end
+
+      it 'should load Regexp' do
+        write_state_file(<<~END)
+          system_value:
+            - !ruby/regexp /regexp/
+        END
+
+        persistence = Puppet::Transaction::Persistence.new
+        expect(persistence.load.dig("system_value")).to contain_exactly(be_a(Regexp))
+      end
+
+      it 'should load semantic puppet version' do
+        write_state_file(<<~END)
+          system_value:
+            - !ruby/object:SemanticPuppet::Version
+              major: 1
+              minor: 0
+              patch: 0
+              prerelease: 
+              build: 
+        END
+
+        persistence = Puppet::Transaction::Persistence.new
+        expect(persistence.load.dig("system_value")).to contain_exactly(be_a(SemanticPuppet::Version))
+      end
+
+      it 'should load puppet time related objects' do
+        write_state_file(<<~END)
+          system_value:
+            - !ruby/object:Puppet::Pops::Time::Timestamp
+              nsecs: 1638316135955087259
+            - !ruby/object:Puppet::Pops::Time::TimeData
+              nsecs: 1495789430910161286
+            - !ruby/object:Puppet::Pops::Time::Timespan
+              nsecs: 1495789430910161286
+        END
+
+        persistence = Puppet::Transaction::Persistence.new
+        expect(persistence.load.dig("system_value")).to contain_exactly(be_a(Puppet::Pops::Time::Timestamp), be_a(Puppet::Pops::Time::TimeData), be_a(Puppet::Pops::Time::Timespan))
+      end
+
+      it 'should load binary objects' do
+        write_state_file(<<~END)
+          system_value:
+            - !ruby/object:Puppet::Pops::Types::PBinaryType::Binary
+              binary_buffer: ''
+        END
+
+        persistence = Puppet::Transaction::Persistence.new
+        expect(persistence.load.dig("system_value")).to contain_exactly(be_a(Puppet::Pops::Types::PBinaryType::Binary))
+      end
     end
   end
 

data/spec/unit/type/file/group_spec.rb

@@ -27,6 +27,13 @@ describe Puppet::Type.type(:file).attrclass(:group) do
       expect { group.insync?(5) }.to raise_error(/Could not find group foos/)
     end
 
+    it "should return false if a group's id can't be found by name in noop" do
+      Puppet[:noop] = true
+      allow(resource.provider).to receive(:name2gid).and_return(nil)
+
+      expect(group.insync?('notcreatedyet')).to eq(false)
+    end
+
     it "should use the id for comparisons, not the name" do
       expect(group.insync?('foos')).to be_falsey
     end

data/spec/unit/type/file/owner_spec.rb

@@ -25,6 +25,13 @@ describe Puppet::Type.type(:file).attrclass(:owner) do
       expect { owner.insync?(5) }.to raise_error(/Could not find user foo/)
     end
 
+    it "should return false if an owner's id can't be found by name in noop" do
+      Puppet[:noop] = true
+      allow(resource.provider).to receive(:name2uid).and_return(nil)
+
+      expect(owner.insync?('notcreatedyet')).to eq(false)
+    end
+
     it "should use the id for comparisons, not the name" do
       expect(owner.insync?('foo')).to be_falsey
     end

data/spec/unit/type/service_spec.rb

@@ -158,6 +158,33 @@ describe test_title, "when validating attribute values" do
         expect(srv[:timeout]).to eq(int)
       end
     end
+
+    it "should default :timeout to 10 when provider has no default value" do
+      srv = Puppet::Type.type(:service).new(:name => "yay")
+      expect(srv[:timeout]).to eq(10)
+    end
+
+    it "should default :timeout to provider given default time when it has one" do
+      provider_class_with_timeout = Puppet::Type.type(:service).provide(:simple) do
+        has_features :configurable_timeout
+        def default_timeout
+          30
+        end
+      end
+      allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class_with_timeout)
+
+      srv = Puppet::Type.type(:service).new(:name => "yay")
+      expect(srv[:timeout]).to eq(30)
+    end
+
+    it "should accept string as value" do
+      srv = Puppet::Type.type(:service).new(:name => "yay", :timeout => "25")
+      expect(srv[:timeout]).to eq(25)
+    end
+
+    it "should not support values that cannot be converted to Integer such as Array" do
+      expect { Puppet::Type.type(:service).new(:name => "yay", :timeout => [25]) }.to raise_error(Puppet::Error)
+    end
   end
 
   describe "the service logon credentials" do 

data/spec/unit/type/user_spec.rb

@@ -174,51 +174,6 @@ describe Puppet::Type.type(:user) do
     end
   end
 
-  describe "when managing the purge_ssh_keys property" do
-    context "with valid input" do
-      it "should support a :true value" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => :true) }.to_not raise_error
-      end
-
-      it "should support a :false value" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => :false) }.to_not raise_error
-      end
-
-      it "should support a String value" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => File.expand_path('home/foo/.ssh/authorized_keys')) }.to_not raise_error
-      end
-
-      it "should support an Array value" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => [File.expand_path('home/foo/.ssh/authorized_keys'),
-          File.expand_path('custom/authorized_keys')]) }.to_not raise_error
-      end
-    end
-
-    context "with faulty input" do
-      it "should raise error for relative path" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => 'home/foo/.ssh/authorized_keys') }.to raise_error(Puppet::ResourceError,
-          /Paths to keyfiles must be absolute/ )
-      end
-
-      it "should raise error for invalid type" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => :invalid) }.to raise_error(Puppet::ResourceError,
-          /purge_ssh_keys must be true, false, or an array of file names/ )
-      end
-
-      it "should raise error for array with relative path" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => ['home/foo/.ssh/authorized_keys',
-          File.expand_path('custom/authorized_keys')]) }.to raise_error(Puppet::ResourceError,
-          /Paths to keyfiles must be absolute/ )
-      end
-
-      it "should raise error for array with invalid type" do
-        expect { described_class.new(:name => 'foo', :purge_ssh_keys => [:invalid,
-          File.expand_path('custom/authorized_keys')]) }.to raise_error(Puppet::ResourceError,
-          /Each entry for purge_ssh_keys must be a string/ )
-      end
-    end
-  end
-
   describe "when managing the uid property" do
     it "should convert number-looking strings into actual numbers" do
       expect(described_class.new(:name => 'foo', :uid => '50')[:uid]).to eq(50)

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 => Facter.value(:operatingsystem)
+          defaultfor :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem)
           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 => Facter.value(:operatingsystem)
+          defaultfor :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem)
           mk_resource_methods
           class << self
             attr_accessor :names

data/spec/unit/util/autoload_spec.rb

@@ -178,15 +178,14 @@ describe Puppet::Util::Autoload do
   end
 
   describe "when loading all files" do
+    let(:basedir) { tmpdir('autoloader') }
+    let(:path) { File.join(basedir, @autoload.path, 'file.rb') }
+
     before do
-      allow(@autoload.class).to receive(:search_directories).and_return([make_absolute("/a")])
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(Dir).to receive(:glob).and_return([make_absolute("/a/foo/file.rb")])
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      @time_a = Time.utc(2010, 'jan', 1, 6, 30)
-      allow(File).to receive(:mtime).and_return(@time_a)
+      FileUtils.mkdir_p(File.dirname(path))
+      FileUtils.touch(path)
 
-      allow(@autoload.class).to receive(:loaded?).and_return(false)
+      allow(@autoload.class).to receive(:search_directories).and_return([basedir])
     end
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
@@ -198,7 +197,25 @@ describe Puppet::Util::Autoload do
     end
 
     it "should require the full path to the file" do
-      expect(Kernel).to receive(:load).with(make_absolute("/a/foo/file.rb"), any_args)
+      expect(Kernel).to receive(:load).with(path, any_args)
+
+      @autoload.loadall(env)
+    end
+
+    it "autoloads from a directory whose ancestor is Windows 8.3", if: Puppet::Util::Platform.windows? do
+      # File.expand_path will expand ~ in the last directory component only(!)
+      # so create an ancestor directory with a long path
+      dir = File.join(tmpdir('longpath'), 'short')
+      path = File.join(dir, @autoload.path, 'file.rb')
+
+      FileUtils.mkdir_p(File.dirname(path))
+      FileUtils.touch(path)
+
+      dir83 = File.join(File.dirname(basedir), 'longpa~1', 'short')
+      path83 = File.join(dir83, @autoload.path, 'file.rb')
+
+      allow(@autoload.class).to receive(:search_directories).and_return([dir83])
+      expect(Kernel).to receive(:load).with(path83, any_args)
 
       @autoload.loadall(env)
     end

data/spec/unit/util/json_spec.rb

@@ -0,0 +1,126 @@
+# coding: utf-8
+require 'spec_helper'
+require 'puppet/util/json'
+
+describe Puppet::Util::Json do
+  include PuppetSpec::Files
+
+  shared_examples_for 'json file loader' do |load_method|
+    it 'reads a JSON file from disk' do
+      file_path = file_containing('input', JSON.dump({ "my" => "data" }))
+
+      expect(load_method.call(file_path)).to eq({ "my" => "data" })
+    end
+
+    it 'reads JSON as UTF-8' do
+      file_path = file_containing('input', JSON.dump({ "my" => "𠜎" }))
+
+      expect(load_method.call(file_path)).to eq({ "my" => "𠜎" })
+    end
+  end
+
+  context "#load" do
+    it 'raises an error if JSON is invalid' do
+      expect {
+        Puppet::Util::Json.load('{ invalid')
+      }.to raise_error(Puppet::Util::Json::ParseError, /unexpected token at '{ invalid'/)
+    end
+
+    it 'raises an error if the content is empty' do
+      expect {
+        Puppet::Util::Json.load('')
+      }.to raise_error(Puppet::Util::Json::ParseError)
+    end
+
+    it 'loads true' do
+      expect(Puppet::Util::Json.load('true')).to eq(true)
+    end
+
+    it 'loads false' do
+      expect(Puppet::Util::Json.load('false')).to eq(false)
+    end
+
+    it 'loads a numeric' do
+      expect(Puppet::Util::Json.load('42')).to eq(42)
+    end
+
+    it 'loads a string' do
+      expect(Puppet::Util::Json.load('"puppet"')).to eq('puppet')
+    end
+
+    it 'loads an array' do
+      expect(Puppet::Util::Json.load(<<~JSON)).to eq([1, 2])
+        [1, 2]
+      JSON
+    end
+
+    it 'loads a hash' do
+      expect(Puppet::Util::Json.load(<<~JSON)).to eq('a' => 1, 'b' => 2)
+        {
+          "a": 1,
+          "b": 2
+        }
+      JSON
+    end
+  end
+
+  context "load_file_if_valid" do
+    before do
+      Puppet[:log_level] = 'debug'
+    end
+
+    it_should_behave_like 'json file loader', Puppet::Util::Json.method(:load_file_if_valid)
+
+    it 'returns nil when the file is invalid JSON and debug logs about it' do
+      file_path = file_containing('input', '{ invalid')
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve JSON content .+: unexpected token at '{ invalid'/).and_call_original
+
+      expect(Puppet::Util::Json.load_file_if_valid(file_path)).to eql(nil)
+    end
+
+    it 'returns nil when the filename is illegal and debug logs about it' do
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve JSON content .+: pathname contains null byte/).and_call_original
+
+      expect(Puppet::Util::Json.load_file_if_valid("not\0allowed")).to eql(nil)
+    end
+
+    it 'returns nil when the file does not exist and debug logs about it' do
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve JSON content .+: No such file or directory/).and_call_original
+
+      expect(Puppet::Util::Json.load_file_if_valid('does/not/exist.json')).to eql(nil)
+    end
+  end
+
+  context '#load_file' do
+    it_should_behave_like 'json file loader', Puppet::Util::Json.method(:load_file)
+
+    it 'raises an error when the file is invalid JSON' do
+      file_path = file_containing('input', '{ invalid')
+
+      expect {
+        Puppet::Util::Json.load_file(file_path)
+      }.to raise_error(Puppet::Util::Json::ParseError, /unexpected token at '{ invalid'/)
+    end
+
+    it 'raises an error when the filename is illegal' do
+      expect {
+        Puppet::Util::Json.load_file("not\0allowed")
+      }.to raise_error(ArgumentError, /null byte/)
+    end
+
+    it 'raises an error when the file does not exist' do
+      expect {
+        Puppet::Util::Json.load_file('does/not/exist.json')
+      }.to raise_error(Errno::ENOENT, /No such file or directory/)
+    end
+
+    it 'writes data formatted as JSON to disk' do
+      file_path = file_containing('input', Puppet::Util::Json.dump({ "my" => "data" }))
+
+      expect(Puppet::Util::Json.load_file(file_path)).to eq({ "my" => "data" })
+    end
+  end
+end

data/spec/unit/util/logging_spec.rb

@@ -552,6 +552,7 @@ original
 
     describe 'does support debugging' do
       before :each do
+        allow(Facter).to receive(:respond_to?).with(:on_message).and_return(true)
         allow(Facter).to receive(:respond_to?).with(:debugging, any_args).and_return(true)
       end
 
@@ -568,6 +569,7 @@ original
 
     describe 'does support trace' do
       before :each do
+        allow(Facter).to receive(:respond_to?).with(:on_message)
         allow(Facter).to receive(:respond_to?).with(:trace, any_args).and_return(true)
       end
 

data/spec/unit/util/yaml_spec.rb

@@ -1,6 +1,5 @@
 # coding: utf-8
 require 'spec_helper'
-
 require 'puppet/util/yaml'
 
 describe Puppet::Util::Yaml do
@@ -10,21 +9,21 @@ describe Puppet::Util::Yaml do
 
   shared_examples_for 'yaml file loader' do |load_method|
     it 'returns false when the file is empty' do
-      Puppet::FileSystem.touch(filename)
+      file_path = file_containing('input', '')
 
-      expect(load_method.call(filename)).to eq(false)
+      expect(load_method.call(file_path)).to eq(false)
     end
 
     it 'reads a YAML file from disk' do
-      write_file(filename, YAML.dump({ "my" => "data" }))
+      file_path = file_containing('input', YAML.dump({ "my" => "data" }))
 
-      expect(load_method.call(filename)).to eq({ "my" => "data" })
+      expect(load_method.call(file_path)).to eq({ "my" => "data" })
     end
 
     it 'reads YAML as UTF-8' do
-      write_file(filename, YAML.dump({ "my" => "𠜎" }))
+      file_path = file_containing('input', YAML.dump({ "my" => "𠜎" }))
 
-      expect(load_method.call(filename)).to eq({ "my" => "𠜎" })
+      expect(load_method.call(file_path)).to eq({ "my" => "𠜎" })
     end
   end
 
@@ -119,11 +118,11 @@ FACTS
     it_should_behave_like 'yaml file loader', Puppet::Util::Yaml.method(:safe_load_file)
 
     it 'raises an error when the file is invalid YAML' do
-      write_file(filename, '{ invalid')
+      file_path = file_containing('input', '{ invalid')
 
       expect {
-        Puppet::Util::Yaml.safe_load_file(filename)
-      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, %r[\(#{filename}\): .* at line \d+ column \d+])
+        Puppet::Util::Yaml.safe_load_file(file_path)
+      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, %r[\(#{file_path}\): .* at line \d+ column \d+])
     end
 
     it 'raises an error when the filename is illegal' do
@@ -139,9 +138,34 @@ FACTS
     end
   end
 
-  def write_file(name, contents)
-    File.open(name, "w:UTF-8") do |fh|
-      fh.write(contents)
+  context "#safe_load_file_if_valid" do
+    before do
+      Puppet[:log_level] = 'debug'
+    end
+
+    it_should_behave_like 'yaml file loader', Puppet::Util::Yaml.method(:safe_load_file_if_valid)
+
+    it 'returns nil when the file is invalid YAML and debug logs about it' do
+      file_path = file_containing('input', '{ invalid')
+
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve YAML content .+ expected ',' or '}'/).and_call_original
+
+      expect(Puppet::Util::Yaml.safe_load_file_if_valid(file_path)).to eql(nil)
+    end
+
+    it 'returns nil when the filename is illegal and debug logs about it' do
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve YAML content .+: pathname contains null byte/).and_call_original
+
+      expect(Puppet::Util::Yaml.safe_load_file_if_valid("not\0allowed")).to eql(nil)
+    end
+
+    it 'returns nil when the file does not exist and debug logs about it' do
+      expect(Puppet).to receive(:debug)
+        .with(/Could not retrieve YAML content .+: No such file or directory/).and_call_original
+
+      expect(Puppet::Util::Yaml.safe_load_file_if_valid('does/not/exist.yaml')).to eql(nil)
     end
   end
 end