puppet 4.1.0 → 5.0.0

data/spec/unit/type/file_spec.rb

@@ -342,6 +342,18 @@ describe Puppet::Type.type(:file) do
       expect(file[:path]).to eq(title)
     end
 
+    it "should allow a single slash for a title and create the path" do
+      title = File.expand_path("/")
+      file = described_class.new(:title => title)
+      expect(file[:path]).to eq(title)
+    end
+
+    it "should allow multiple slashes for a title and create the path" do
+      title = File.expand_path("/") + "//"
+      file = described_class.new(:title => title)
+      expect(file[:path]).to eq(File.expand_path("/"))
+    end
+
     it "should set a desired 'ensure' value if none is set and 'content' is set" do
       file = described_class.new(:path => path, :content => "/foo/bar")
       expect(file[:ensure]).to eq(:file)
@@ -351,6 +363,22 @@ describe Puppet::Type.type(:file) do
       file = described_class.new(:path => path, :target => File.expand_path(__FILE__))
       expect(file[:ensure]).to eq(:link)
     end
+
+    describe "marking parameters as sensitive" do
+      it "marks sensitive, content, and ensure as sensitive when source is sensitive" do
+        resource = Puppet::Resource.new(:file, make_absolute("/tmp/foo"), :parameters => {:source => make_absolute('/tmp/bar')}, :sensitive_parameters => [:source])
+        file = described_class.new(resource)
+        expect(file.parameter(:source).sensitive).to eq true
+        expect(file.property(:content).sensitive).to eq true
+        expect(file.property(:ensure).sensitive).to eq true
+      end
+
+      it "marks ensure as sensitive when content is sensitive" do
+        resource = Puppet::Resource.new(:file, make_absolute("/tmp/foo"), :parameters => {:content => 'hello world!'}, :sensitive_parameters => [:content])
+        file = described_class.new(resource)
+        expect(file.property(:ensure).sensitive).to eq true
+      end
+    end
   end
 
   describe "#mark_children_for_purging" do
@@ -418,7 +446,7 @@ describe Puppet::Type.type(:file) do
     it "should not copy values to the child which were set by the source" do
       source = File.expand_path(__FILE__)
       file[:source] = source
-      metadata = stub 'metadata', :owner => "root", :group => "root", :mode => '0755', :ftype => "file", :checksum => "{md5}whatever", :source => source
+      metadata = stub 'metadata', :owner => "root", :group => "root", :mode => '0755', :ftype => "file", :checksum => "{md5}whatever", :checksum_type => "md5", :source => source
       file.parameter(:source).stubs(:metadata).returns metadata
 
       file.parameter(:source).copy_source_values
@@ -518,19 +546,6 @@ describe Puppet::Type.type(:file) do
 
   end
 
-  describe "#remove_less_specific_files" do
-    it "should remove any nested files that are already in the catalog" do
-      foo = described_class.new :path => File.join(file[:path], 'foo')
-      bar = described_class.new :path => File.join(file[:path], 'bar')
-      baz = described_class.new :path => File.join(file[:path], 'baz')
-
-      catalog.add_resource(foo)
-      catalog.add_resource(bar)
-
-      expect(file.remove_less_specific_files([foo, bar, baz])).to eq([baz])
-    end
-  end
-
   describe "#remove_less_specific_files" do
     it "should remove any nested files that are already in the catalog" do
       foo = described_class.new :path => File.join(file[:path], 'foo')
@@ -720,6 +735,13 @@ describe Puppet::Type.type(:file) do
       file.recurse_remote("first" => @resource)
     end
 
+    it "should set the checksum parameter based on the metadata" do
+      file.stubs(:perform_recursion).returns [@first]
+      @resource.stubs(:[]=)
+      @resource.expects(:[]=).with(:checksum, "md5")
+      file.recurse_remote("first" => @resource)
+    end
+
     it "should store the metadata in the source property for each resource so the source does not have to requery the metadata" do
       file.stubs(:perform_recursion).returns [@first]
       @resource.expects(:parameter).with(:source).returns @parameter
@@ -747,6 +769,16 @@ describe Puppet::Type.type(:file) do
       file.recurse_remote("first" => @resource)
     end
 
+    it "should update the main file's checksum parameter if the relative path is '.'" do
+      @first.stubs(:relative_path).returns "."
+      file.stubs(:perform_recursion).returns [@first]
+
+      file.stubs(:[]=)
+      file.expects(:[]=).with(:checksum, "md5")
+
+      file.recurse_remote("first" => @resource)
+    end
+
     describe "and multiple sources are provided" do
       let(:sources) do
         h = {}
@@ -1070,11 +1102,13 @@ describe Puppet::Type.type(:file) do
       it "should fail if the checksum parameter and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b', :sum_file => 'checksum_b')
         file.stubs(:parameter).with(:checksum).returns(checksum)
+        file.stubs(:parameter).with(:source).returns(nil)
+
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         file.stubs(:property).with(:content).returns(property)
 
-        expect { file.write :NOTUSED }.to raise_error(Puppet::Error)
+        expect { file.write property }.to raise_error(Puppet::Error)
       end
     end
 
@@ -1084,11 +1118,12 @@ describe Puppet::Type.type(:file) do
       it "should not fail if the checksum property and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b')
         file.stubs(:parameter).with(:checksum).returns(checksum)
+        file.stubs(:parameter).with(:source).returns(nil)
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         file.stubs(:property).with(:content).returns(property)
 
-        expect { file.write :NOTUSED }.to_not raise_error
+        expect { file.write property }.to_not raise_error
       end
     end
 
@@ -1101,13 +1136,13 @@ describe Puppet::Type.type(:file) do
         it "should convert symbolic mode to int" do
           file[:mode] = 'oga=r'
           Puppet::Util.expects(:replace_file).with(file[:path], 0444)
-          file.write :NOTUSED
+          file.write
         end
 
         it "should support int modes" do
           file[:mode] = '0444'
           Puppet::Util.expects(:replace_file).with(file[:path], 0444)
-          file.write :NOTUSED
+          file.write
         end
       end
 
@@ -1117,19 +1152,19 @@ describe Puppet::Type.type(:file) do
         it "should set a umask of 0" do
           file[:mode] = 'oga=r'
           Puppet::Util.expects(:withumask).with(0)
-          file.write :NOTUSED
+          file.write
         end
 
         it "should convert symbolic mode to int" do
           file[:mode] = 'oga=r'
           File.expects(:open).with(file[:path], anything, 0444)
-          file.write :NOTUSED
+          file.write
         end
 
         it "should support int modes" do
           file[:mode] = '0444'
           File.expects(:open).with(file[:path], anything, 0444)
-          file.write :NOTUSED
+          file.write
         end
       end
     end
@@ -1139,7 +1174,7 @@ describe Puppet::Type.type(:file) do
         it "should default to 0644 mode" do
           file = described_class.new(:path => path, :content => "file content")
 
-          file.write :NOTUSED
+          file.write file.parameter(:content)
 
           expect(File.stat(file[:path]).mode & 0777).to eq(0644)
         end
@@ -1151,7 +1186,7 @@ describe Puppet::Type.type(:file) do
 
           umask_from_the_user = 0777
           Puppet::Util.withumask(umask_from_the_user) do
-            file.write :NOTUSED
+            file.write
           end
 
           expect(File.stat(file[:path]).mode & 0777).to eq(0644)
@@ -1189,16 +1224,6 @@ describe Puppet::Type.type(:file) do
     end
   end
 
-  describe "#write_content" do
-    it "should delegate writing the file to the content property" do
-      io = stub('io')
-      file[:content] = "some content here"
-      file.property(:content).expects(:write).with(io)
-
-      file.send(:write_content, io)
-    end
-  end
-
   describe "#write_temporary_file?" do
     it "should be true if the file has specified content" do
       file[:content] = 'some content'
@@ -1390,10 +1415,67 @@ describe Puppet::Type.type(:file) do
     end
   end
 
+  describe 'when using source' do
+    # different UTF-8 widths
+    # 1-byte A
+    # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+    # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+    # 4-byte <U+070E> - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+    let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ<U+070E>
+
+    it 'should allow UTF-8 characters and return a UTF-8 uri' do
+      filename = "/bar #{mixed_utf8}"
+      source = "puppet://foo#{filename}"
+      file[:source] = source
+
+      # intercept the indirector call to provide back mocked metadata for the given URI
+      metadata = stub 'metadata', :source => source
+      metadata.expects(:source=)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with do |path, opts|
+        path == source
+      end.returns metadata
+
+      uri = file.parameters[:source].uri
+      expect(URI.unescape(uri.path)).to eq(filename)
+      expect(uri.path.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it 'should allow UTF-8 characters inside the indirector / terminus code' do
+      filename = "/bar #{mixed_utf8}"
+      source = "puppet://foo#{filename}"
+      file[:source] = source
+
+      # for this test to properly trigger previously errant behavior, the code for
+      # Puppet::FileServing::Metadata.indirection.find must run and produce an
+      # instance of Puppet::Indirector::FileMetadata::Rest that can be amended
+      metadata = stub 'metadata', :source => source
+      metadata.expects(:source=)
+      require 'puppet/indirector/file_metadata/rest'
+      Puppet::Indirector::FileMetadata::Rest.any_instance.expects(:find).with do |req|
+        req.key == filename[1..-1]
+      end.returns(metadata)
+
+      uri = file.parameters[:source].uri
+      expect(URI.unescape(uri.path)).to eq(filename)
+      expect(uri.path.encoding).to eq(Encoding::UTF_8)
+    end
+  end
+
   describe "when using source" do
     before do
       file[:source] = File.expand_path('/one')
+      @checksum_values = {
+        :md5 => 'd41d8cd98f00b204e9800998ecf8427e',
+        :md5lite => 'd41d8cd98f00b204e9800998ecf8427e',
+        :sha256 => 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+        :sha256lite => 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+        :sha1 => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
+        :sha1lite => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
+        :mtime => 'Jan 26 13:59:49 2016',
+        :ctime => 'Jan 26 13:59:49 2016'
+      }
     end
+
     Puppet::Type::File::ParameterChecksum.value_collection.values.reject {|v| v == :none}.each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         before do
@@ -1401,12 +1483,66 @@ describe Puppet::Type.type(:file) do
         end
 
         it 'should validate' do
+          expect { file.validate }.to_not raise_error
+        end
+
+        it 'should fail on an invalid checksum_value' do
+          file[:checksum_value] = ''
+          expect { file.validate }.to raise_error(Puppet::Error, "Checksum value '' is not a valid checksum type #{checksum_type}")
+        end
 
+        it 'should validate a valid checksum_value' do
+          file[:checksum_value] = @checksum_values[checksum_type]
           expect { file.validate }.to_not raise_error
         end
       end
     end
 
+    describe "on Windows when source_permissions is `use`" do
+      before :each do
+        Puppet.features.stubs(:microsoft_windows?).returns true
+        file[:source_permissions] = "use"
+      end
+      let(:err_message) { "Copying owner/mode/group from the" <<
+                          " source file on Windows is not supported;" <<
+                          " use source_permissions => ignore." }
+
+      it "should issue error when retrieving" do
+        expect { file.retrieve }.to raise_error(err_message)
+      end
+
+      it "should issue error when retrieving if only user is unspecified" do
+        file[:group] = 2
+        file[:mode] = "0003"
+
+        expect { file.retrieve }.to raise_error(err_message)
+      end
+
+      it "should issue error when retrieving if only group is unspecified" do
+        file[:owner] = 1
+        file[:mode] = "0003"
+
+        expect { file.retrieve }.to raise_error(err_message)
+      end
+
+      it "should issue error when retrieving if only mode is unspecified" do
+        file[:owner] = 1
+        file[:group] = 2
+
+        expect { file.retrieve }.to raise_error(err_message)
+      end
+
+      it "should issue warning when retrieve if group, owner, and mode are all specified" do
+        file[:owner] = 1
+        file[:group] = 2
+        file[:mode] = "0003"
+
+        file.parameter(:source).expects(:copy_source_values)
+        file.expects(:warning).with(err_message)
+        expect { file.retrieve }.not_to raise_error
+      end
+    end
+
     describe "with checksum 'none'" do
       before do
         file[:checksum] = :none
@@ -1421,6 +1557,14 @@ describe Puppet::Type.type(:file) do
   describe "when using content" do
     before do
       file[:content] = 'file contents'
+      @checksum_values = {
+        :md5 => 'd41d8cd98f00b204e9800998ecf8427e',
+        :md5lite => 'd41d8cd98f00b204e9800998ecf8427e',
+        :sha256 => 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+        :sha256lite => 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+        :sha1 => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
+        :sha1lite => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
+      }
     end
 
     (Puppet::Type::File::ParameterChecksum.value_collection.values - SOURCE_ONLY_CHECKSUMS).each do |checksum_type|
@@ -1432,6 +1576,16 @@ describe Puppet::Type.type(:file) do
         it 'should validate' do
           expect { file.validate }.to_not raise_error
         end
+
+        it 'should fail on an invalid checksum_value' do
+          file[:checksum_value] = ''
+          expect { file.validate }.to raise_error(Puppet::Error, "Checksum value '' is not a valid checksum type #{checksum_type}")
+        end
+
+        it 'should validate a valid checksum_value' do
+          file[:checksum_value] = @checksum_values[checksum_type]
+          expect { file.validate }.to_not raise_error
+        end
       end
     end
 
@@ -1446,6 +1600,26 @@ describe Puppet::Type.type(:file) do
     end
   end
 
+  describe "when checksum is none" do
+    before do
+      file[:checksum] = :none
+    end
+
+    it 'should validate' do
+      expect { file.validate }.to_not raise_error
+    end
+
+    it 'should fail on an invalid checksum_value' do
+      file[:checksum_value] = 'boo'
+      expect { file.validate }.to raise_error(Puppet::Error, "Checksum value 'boo' is not a valid checksum type none")
+    end
+
+    it 'should validate a valid checksum_value' do
+      file[:checksum_value] = ''
+      expect { file.validate }.to_not raise_error
+    end
+  end
+
   describe "when auditing" do
     before :each do
       # to prevent the catalog from trying to write state.yaml
@@ -1470,7 +1644,10 @@ describe Puppet::Type.type(:file) do
       catalog.apply
 
       expect(Puppet::FileSystem.exist?(path)).to be_truthy
-      expect(@logs).not_to be_any {|l| l.level != :notice }
+      expect(@logs).not_to be_any { |l|
+        # the audit metaparameter is deprecated and logs a warning
+        l.level != :notice
+      }
     end
   end
 
@@ -1501,5 +1678,4 @@ describe Puppet::Type.type(:file) do
       end
     end
   end
-
 end

data/spec/unit/type/host_spec.rb

@@ -68,15 +68,15 @@ describe host do
     end
 
     it "should not accept malformed IPv4 addresses like 192.168.0.300" do
-      expect { @class.new(:name => "foo", :ip => '192.168.0.300') }.to raise_error
+      expect { @class.new(:name => "foo", :ip => '192.168.0.300') }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
     end
 
     it "should reject over-long IPv4 addresses" do
-      expect { @class.new(:name => "foo", :ip => '10.10.10.10.10') }.to raise_error
+      expect { @class.new(:name => "foo", :ip => '10.10.10.10.10') }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
     end
 
     it "should not accept malformed IP addresses like 2001:0dg8:85a3:08d3:1319:8a2e:0370:7344" do
-      expect { @class.new(:name => "foo", :ip => '2001:0dg8:85a3:08d3:1319:8a2e:0370:7344') }.to raise_error
+      expect { @class.new(:name => "foo", :ip => '2001:0dg8:85a3:08d3:1319:8a2e:0370:7344') }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
     end
 
     # Assorted, annotated IPv6 passes.
@@ -598,7 +598,7 @@ describe host do
      "::2222:3333:4444:5555:6666:7777:8888:",
     ].each do |ip|
       it "should reject #{ip.inspect} as an IPv6 address" do
-        expect { @class.new(:name => "foo", :ip => ip) }.to raise_error
+        expect { @class.new(:name => "foo", :ip => ip) }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
       end
     end
 

data/spec/unit/type/interface_spec.rb

@@ -67,6 +67,38 @@ describe Puppet::Type.type(:interface) do
       end
     end
 
+    describe "interface mode" do
+      it "should allow :access" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :mode => :access)
+      end
+
+      it "should allow :trunk" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :mode => :trunk)
+      end
+
+      it "should allow 'dynamic auto'" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :mode => 'dynamic auto')
+      end
+
+      it "should allow 'dynamic desirable'" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :mode => 'dynamic desirable')
+      end
+    end
+
+    describe "interface encapsulation" do
+      it "should allow :dot1q" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :encapsulation => :dot1q)
+      end
+
+      it "should allow :isl" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :encapsulation => :isl)
+      end
+
+      it "should allow :negotiate" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :encapsulation => :negotiate)
+      end
+    end
+
     describe "especially ipaddress" do
       it "should allow ipv4 addresses" do
         Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :ipaddress => "192.168.0.1/24")

data/spec/unit/type/macauthorization_spec.rb

@@ -1,6 +1,9 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
+module Puppet::Util::Plist
+end
+
 macauth_type = Puppet::Type.type(:macauthorization)
 
 describe Puppet::Type.type(:macauthorization), "when checking macauthorization objects" do
@@ -10,7 +13,7 @@ describe Puppet::Type.type(:macauthorization), "when checking macauthorization o
     authplist["rules"] = { "foorule" => "foo" }
     authplist["rights"] = { "fooright" => "foo" }
     provider_class = macauth_type.provider(macauth_type.providers[0])
-    Plist.stubs(:parse_xml).with("/etc/authorization").returns(authplist)
+    Puppet::Util::Plist.stubs(:parse_plist).with("/etc/authorization").returns(authplist)
     macauth_type.stubs(:defaultprovider).returns provider_class
     @resource = macauth_type.new(:name => 'foo')
   end

data/spec/unit/type/mount_spec.rb

@@ -197,6 +197,10 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       it "should not support whitespace in fstype" do
         expect { described_class.new(:name => "/foo", :ensure => :present, :fstype => 'ext 3') }.to raise_error Puppet::Error, /fstype.*whitespace/
       end
+
+      it "should not support an empty string in fstype" do
+        expect { described_class.new(:name => "/foo", :ensure => :present, :fstype => "") }.to raise_error Puppet::Error, /fstype.*empty string/
+      end
     end
 
     describe "for options" do
@@ -211,6 +215,10 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       it "should not support whitespace in options" do
         expect { described_class.new(:name => "/foo", :ensure => :present, :options => ['ro','foo bar','intr']) }.to raise_error Puppet::Error, /option.*whitespace/
       end
+
+      it "should not support an empty string in options" do
+        expect { described_class.new(:name => "/foo", :ensure => :present, :options => "") }.to raise_error Puppet::Error, /option.*empty string/
+      end
     end
 
     describe "for pass" do
@@ -537,15 +545,23 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
     end
   end
 
-  describe "establishing autorequires" do
+  describe "establishing autorequires and autobefores" do
 
-    def create_resource(path)
+    def create_mount_resource(path)
       described_class.new(
         :name => path,
         :provider => providerclass.new(path)
       )
     end
 
+    def create_file_resource(path)
+      file_class = Puppet::Type.type(:file)
+      file_class.new(
+        :path => path,
+        :provider => file_class.new(:path => path).provider
+      )
+    end
+
     def create_catalog(*resources)
       catalog = Puppet::Resource::Catalog.new
       resources.each do |resource|
@@ -555,19 +571,23 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       catalog
     end
 
-    let(:root_mount) { create_resource("/") }
-    let(:var_mount)  { create_resource("/var") }
-    let(:log_mount)  { create_resource("/var/log") }
+    let(:root_mount) { create_mount_resource("/") }
+    let(:var_mount)  { create_mount_resource("/var") }
+    let(:log_mount)  { create_mount_resource("/var/log") }
+    let(:var_file) { create_file_resource('/var') }
+    let(:log_file) { create_file_resource('/var/log') }
+    let(:puppet_file) { create_file_resource('/var/log/puppet') }
+    let(:opt_file) { create_file_resource('/opt/var/puppet') }
 
     before do
-      create_catalog(root_mount, var_mount, log_mount)
+      create_catalog(root_mount, var_mount, log_mount, var_file, log_file, puppet_file, opt_file)
     end
 
     it "adds no autorequires for the root mount" do
       expect(root_mount.autorequire).to be_empty
     end
 
-    it "adds the parent autorequire for a mount with one parent" do
+    it "adds the parent autorequire and the file autorequire for a mount with one parent" do
       parent_relationship = var_mount.autorequire[0]
 
       expect(var_mount.autorequire).to have_exactly(1).item
@@ -576,7 +596,7 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       expect(parent_relationship.target).to eq var_mount
     end
 
-    it "adds both parent autorequires for a mount with two parents" do
+    it "adds both parent autorequires and the file autorequire for a mount with two parents" do
       grandparent_relationship = log_mount.autorequire[0]
       parent_relationship = log_mount.autorequire[1]
 
@@ -588,5 +608,27 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       expect(parent_relationship.source).to eq var_mount
       expect(parent_relationship.target).to eq log_mount
     end
+
+    it "adds the child autobefore for a mount with one file child" do
+      child_relationship = log_mount.autobefore[0]
+
+      expect(log_mount.autobefore).to have_exactly(1).item
+
+      expect(child_relationship.source).to eq log_mount
+      expect(child_relationship.target).to eq puppet_file
+    end
+
+    it "adds both child autobefores for a mount with two file children" do
+      child_relationship = var_mount.autobefore[0]
+      grandchild_relationship = var_mount.autobefore[1]
+
+      expect(var_mount.autobefore).to have_exactly(2).items
+
+      expect(child_relationship.source).to eq var_mount
+      expect(child_relationship.target).to eq log_file
+
+      expect(grandchild_relationship.source).to eq var_mount
+      expect(grandchild_relationship.target).to eq puppet_file
+    end
   end
 end

data/spec/unit/type/package_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:package) do
   before do
+    Process.stubs(:euid).returns 0
     Puppet::Util::Storage.stubs(:store)
   end