puppet 4.0.0 → 4.10.0

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -1,9 +1,11 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
+require 'puppet_spec/files'
 
 describe 'function for dynamically creating resources' do
   include PuppetSpec::Compiler
+  include PuppetSpec::Files
 
   before :each do
     node      = Puppet::Node.new("floppy", :environment => 'production')
@@ -31,6 +33,35 @@ describe 'function for dynamically creating resources' do
     expect { @scope.function_create_resources(['foo',{},'foo']) }.to raise_error(ArgumentError, 'create_resources(): third argument, if provided, must be a hash')
   end
 
+  context 'when being called from a manifest in a file' do
+    let(:dir) do
+      dir_containing('manifests', {
+              'site.pp' => <<-EOF
+                # comment here to make the call be on a particular
+                # source line (3)
+                create_resources('notify', {
+                  'a'  => { 'message'=>'message a'},
+                  'b'  => { 'message'=>'message b'},
+                  }
+                )
+              EOF
+          }
+      )
+    end
+
+    it 'file and line information where call originates is written to all resources created in one call' do
+      node = Puppet::Node.new('test')
+      file = File.join(dir, 'site.pp')
+      Puppet[:manifest] = file
+      catalog = Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
+
+      expect(catalog.resource(:notify, 'a').file).to eq(file)
+      expect(catalog.resource(:notify, 'a').line).to eq(3)
+      expect(catalog.resource(:notify, 'b').file).to eq(file)
+      expect(catalog.resource(:notify, 'b').line).to eq(3)
+    end
+
+  end
   describe 'when creating native types' do
     it 'empty hash should not cause resources to be added' do
       noop_catalog = compile_to_catalog("create_resources('file', {})")
@@ -43,6 +74,16 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
     end
 
+    it 'should pick up and pass on file and line information' do
+      # mock location as the compile_to_catalog sets Puppet[:code} which does not
+      # have file/line support.
+      Puppet::Pops::PuppetStack.expects(:stacktrace).once.returns([['test.pp', 1234]])
+      catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
+      r = catalog.resource(:file, "/etc/foo")
+      expect(r.file).to eq('test.pp')
+      expect(r.line).to eq(1234)
+    end
+
     it 'should be able to add virtual resources' do
       catalog = compile_to_catalog("create_resources('@file', {'/etc/foo'=>{'ensure'=>'present'}})\nrealize(File['/etc/foo'])")
       expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
@@ -54,16 +95,16 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:file, "/etc/foo").exported).to eq(true)
     end
 
-    it 'should accept multiple types' do
+    it 'should accept multiple resources' do
       catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'two'}})")
       expect(catalog.resource(:notify, "foo")['message']).to eq('one')
       expect(catalog.resource(:notify, "bar")['message']).to eq('two')
     end
 
-    it 'should fail to add non-existing type' do
+    it 'should fail to add non-existing resource type' do
       expect do
         @scope.function_create_resources(['create-resource-foo', { 'foo' => {} }])
-      end.to raise_error(/Invalid resource type create-resource-foo/)
+      end.to raise_error(/Unknown resource type: 'create-resource-foo'/)
     end
 
     it 'should be able to add edges' do
@@ -75,6 +116,24 @@ describe 'function for dynamically creating resources' do
       expect(rg.path_between(test,foo)).to be
     end
 
+    it 'should filter out undefined edges as they cause errors' do
+      rg = compile_to_relationship_graph("notify { test: }\n create_resources('notify', {'foo'=>{'require'=>undef}})")
+      test  = rg.vertices.find { |v| v.title == 'test' }
+      foo   = rg.vertices.find { |v| v.title == 'foo' }
+      expect(test).to be
+      expect(foo).to be
+      expect(rg.path_between(foo,nil)).to_not be
+    end
+
+    it 'should filter out undefined edges in an array as they cause errors' do
+      rg = compile_to_relationship_graph("notify { test: }\n create_resources('notify', {'foo'=>{'require'=>[undef]}})")
+      test  = rg.vertices.find { |v| v.title == 'test' }
+      foo   = rg.vertices.find { |v| v.title == 'foo' }
+      expect(test).to be
+      expect(foo).to be
+      expect(rg.path_between(foo,nil)).to_not be
+    end
+
     it 'should account for default values' do
       catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}, '/etc/baz'=>{'group'=>'food'}}, {'group' => 'bar'})")
       expect(catalog.resource(:file, "/etc/foo")['group']).to eq('bar')
@@ -103,7 +162,29 @@ describe 'function for dynamically creating resources' do
 
           create_resources('foocreateresource', {'blah'=>{}})
         MANIFEST
-      }.to raise_error(Puppet::Error, 'Must pass one to Foocreateresource[blah] on node foonode')
+      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one'/)
+    end
+
+    it 'should accept undef as explicit value when parameter has no default value' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          define foocreateresource($one) {
+            notify { $name: message => "aaa${one}bbb" }
+          }
+
+          create_resources('foocreateresource', {'blah'=>{ one => undef}})
+        MANIFEST
+      expect(catalog.resource(:notify, "blah")['message']).to eq('aaabbb')
+    end
+
+    it 'should use default value expression if given value is undef' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          define foocreateresource($one = 'xx') {
+            notify { $name: message => "aaa${one}bbb" }
+          }
+
+          create_resources('foocreateresource', {'blah'=>{ one => undef}})
+        MANIFEST
+      expect(catalog.resource(:notify, "blah")['message']).to eq('aaaxxbbb')
     end
 
     it 'should be able to add multiple defines' do
@@ -169,7 +250,7 @@ describe 'function for dynamically creating resources' do
         compile_to_catalog(<<-MANIFEST)
           create_resources('class', {'blah'=>{'one'=>'two'}})
         MANIFEST
-      end.to raise_error(/Could not find declared class blah at line 1:11 on node foonode/)
+      end.to raise_error(/Could not find declared class blah at line 1:11 on node test/)
     end
 
     it 'should be able to add edges' do

data/spec/unit/parser/functions/file_spec.rb

@@ -15,7 +15,7 @@ describe "the 'file' function" do
 
   def with_file_content(content)
     path = tmpfile('file-function')
-    file = File.new(path, 'w')
+    file = File.new(path, 'wb')
     file.sync = true
     file.print content
     yield path
@@ -27,6 +27,12 @@ describe "the 'file' function" do
     end
   end
 
+  it "should read a file keeping line endings intact" do
+    with_file_content("file content\r\n") do |name|
+      expect(scope.function_file([name])).to eq("file content\r\n")
+    end
+  end
+
   it "should read a file from a module path" do
     with_file_content('file content') do |name|
       mod = mock 'module'

data/spec/unit/parser/functions/fqdn_rand_spec.rb

@@ -4,9 +4,13 @@ require 'puppet_spec/scope'
 
 describe "the fqdn_rand function" do
   include PuppetSpec::Scope
-  
+
+  it "returns an integer" do
+    expect(fqdn_rand(3)).to be_an(Integer)
+  end
+
   it "provides a random number strictly less than the given max" do
-    expect(fqdn_rand(3)).to satisfy {|n| n.to_i < 3 }
+    expect(fqdn_rand(3)).to satisfy {|n| n < 3 }
   end
 
   it "provides the same 'random' value on subsequent calls for the same host" do

data/spec/unit/parser/functions/generate_spec.rb

@@ -92,18 +92,9 @@ describe "the generate function" do
   end
 
   let :command do
-    cmd = tmpfile('function_generate')
-
-    if Puppet.features.microsoft_windows?
-      cmd += '.bat'
-      text = '@echo off' + "\n" + 'echo a-%1 b-%2'
-    else
-      text = '#!/bin/sh' + "\n" + 'echo a-$1 b-$2'
-    end
-
-    File.open(cmd, 'w') {|fh| fh.puts text }
-    File.chmod 0700, cmd
-    cmd
+    script_containing('function_generate',
+      :windows => '@echo off' + "\n" + 'echo a-%1 b-%2',
+      :posix   => '#!/bin/sh' + "\n" + 'echo a-$1 b-$2')
   end
 
   after :each do

data/spec/unit/parser/functions/hiera_array_spec.rb

@@ -7,6 +7,6 @@ describe 'Puppet::Parser::Functions#hiera_array' do
   let :scope do create_test_scope_for_node('foo') end
 
   it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera_array(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { scope.function_hiera_array(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/hiera_hash_spec.rb

@@ -7,6 +7,6 @@ describe 'Puppet::Parser::Functions#hiera_hash' do
   let :scope do create_test_scope_for_node('foo') end
 
   it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera_hash(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { scope.function_hiera_hash(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/hiera_include_spec.rb

@@ -7,6 +7,6 @@ describe 'Puppet::Parser::Functions#hiera_include' do
   let :scope do create_test_scope_for_node('foo') end
 
   it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera_include(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { scope.function_hiera_include(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/hiera_spec.rb

@@ -7,6 +7,6 @@ describe 'Puppet::Parser::Functions#hiera' do
   let :scope do create_test_scope_for_node('foo') end
 
   it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_hiera(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { scope.function_hiera(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/lookup_spec.rb

@@ -9,6 +9,6 @@ describe "lookup function" do
   let :scope do create_test_scope_for_node('foo') end
 
   it 'should raise an error since this function is converted to 4x API)' do
-    expect { scope.function_lookup(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { scope.function_lookup(['key']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/regsubst_spec.rb

@@ -19,6 +19,6 @@ describe "the regsubst function" do
         'b[an]*a',
         'coconut'
       ])
-    end.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    end.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/split_spec.rb

@@ -13,6 +13,6 @@ describe "the split function" do
   end
 
   it 'should raise a ParseError' do
-    expect { @scope.function_split([ '130;236;254;10', ';']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
+    expect { @scope.function_split([ '130;236;254;10', ';']) }.to raise_error(Puppet::ParseError, /can only be called using the 4.x function API/)
   end
 end

data/spec/unit/parser/functions/template_spec.rb

@@ -82,7 +82,7 @@ describe "the template function" do
   end
 
   def eval_template(content)
-    File.stubs(:read).with("template").returns(content)
+    Puppet::FileSystem.stubs(:read_preserve_line_endings).with("template").returns(content)
     Puppet::Parser::Files.stubs(:find_template).returns("template")
     scope.function_template(['template'])
   end

data/spec/unit/parser/resource_spec.rb

@@ -54,10 +54,6 @@ describe Puppet::Parser::Resource do
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment).to eq("foo")
   end
 
-  it "should use the resource type collection helper module" do
-    expect(Puppet::Parser::Resource.ancestors).to be_include(Puppet::Resource::TypeCollectionHelper)
-  end
-
   it "should use the scope's environment as its environment" do
     @scope.expects(:environment).returns("myenv").at_least_once
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment).to eq("myenv")
@@ -105,9 +101,9 @@ describe Puppet::Parser::Resource do
       @arguments = {:scope => @scope}
     end
 
-    it "should fail unless #{name.to_s} is specified" do
+    it "should fail unless hash is specified" do
       expect {
-        Puppet::Parser::Resource.new('file', '/my/file')
+        Puppet::Parser::Resource.new('file', '/my/file', nil)
       }.to raise_error(ArgumentError, /Resources require a hash as last argument/)
     end
 
@@ -157,7 +153,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should add an edge to any specified stage for class resources" do
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
 
       other_stage = Puppet::Parser::Resource.new(:stage, "other", :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, other_stage)
@@ -171,7 +167,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should fail if an unknown stage is specified" do
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
 
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'other'
@@ -183,7 +179,7 @@ describe Puppet::Parser::Resource do
       main      = @compiler.catalog.resource(:stage, :main)
       foo_stage = Puppet::Parser::Resource.new(:stage, :foo_stage, :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, foo_stage)
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'foo_stage'
       @compiler.add_resource(@scope, resource)
@@ -193,6 +189,23 @@ describe Puppet::Parser::Resource do
       expect(@compiler.catalog).to be_edge(foo_stage, resource)
     end
 
+    it 'should allow a resource reference to be undef' do
+      Puppet[:code] = "notify { 'hello': message=>'yo', notify => undef }"
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+      edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
+      expect(edges).to include(['Class[main]', 'Notify[hello]'])
+    end
+
+    it 'should evaluate class in the same file without include' do
+      Puppet[:code] = <<-MANIFEST
+        class a($myvar = 'hello') {}
+        class { 'a': myvar => 'goodbye' }
+        notify { $a::myvar: }
+      MANIFEST
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+      expect(catalog.resource('Notify[goodbye]')).to be_a(Puppet::Resource)
+    end
+
     it "should allow edges to propagate multiple levels down the scope hierarchy" do
       Puppet[:code] = <<-MANIFEST
         stage { before: before => Stage[main] }
@@ -239,7 +252,7 @@ describe Puppet::Parser::Resource do
 
     it "should add edges from top-level class resources to the main stage if no stage is specified" do
       main = @compiler.catalog.resource(:stage, :main)
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, resource)
 
@@ -251,9 +264,6 @@ describe Puppet::Parser::Resource do
 
   describe "when finishing" do
     before do
-      @class = newclass "myclass"
-      @nodedef = newnode("mynode")
-
       @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source)
     end
 
@@ -288,6 +298,13 @@ describe Puppet::Parser::Resource do
 
       expect(@resource[:owner]).to eq("other")
     end
+
+    it "converts parameters with Sensitive values to unwrapped values and metadata" do
+      @resource[:content] = Puppet::Pops::Types::PSensitiveType::Sensitive.new("hunter2")
+      @resource.finish
+      expect(@resource[:content]).to eq "hunter2"
+      expect(@resource.sensitive_parameters).to eq [:content]
+    end
   end
 
   describe "when being tagged" do
@@ -531,24 +548,6 @@ describe Puppet::Parser::Resource do
     end
   end
 
-  describe "when validating" do
-    it "should check each parameter" do
-      resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
-      resource[:one] = :two
-      resource[:three] = :four
-      resource.expects(:validate_parameter).with(:one)
-      resource.expects(:validate_parameter).with(:three)
-      resource.send(:validate)
-    end
-
-    it "should raise a parse error when there's a failure" do
-      resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
-      resource[:one] = :two
-      resource.expects(:validate_parameter).with(:one).raises ArgumentError
-      expect { resource.send(:validate) }.to raise_error(Puppet::ParseError)
-    end
-  end
-
   describe "when setting parameters" do
     before do
       @source = newclass "foobar"
@@ -574,7 +573,7 @@ describe Puppet::Parser::Resource do
 
   # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
   it "should not include 'undef' parameters when converting itself to a hash" do
-    resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => mock("scope")
+    resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => @scope
     resource[:owner] = :undef
     resource[:mode] = "755"
     expect(resource.to_hash[:owner]).to be_nil

data/spec/unit/parser/scope_spec.rb

@@ -33,6 +33,15 @@ describe Puppet::Parser::Scope do
     end
   end
 
+  it "should generate a simple string when inspecting a scope" do
+    expect(@scope.inspect).to eq("Scope()")
+  end
+
+  it "should generate a simple string when inspecting a scope with a resource" do
+    @scope.resource="foo::bar"
+    expect(@scope.inspect).to eq("Scope(foo::bar)")
+  end
+
   it "should return a scope for use in a test harness" do
     expect(create_test_scope_for_node("node_name_foo")).to be_a_kind_of(Puppet::Parser::Scope)
   end
@@ -82,10 +91,6 @@ describe Puppet::Parser::Scope do
     }.to raise_error(Puppet::DevError, /you must pass a compiler instance/)
   end
 
-  it "should use the resource type collection helper to find its known resource types" do
-    expect(Puppet::Parser::Scope.ancestors).to include(Puppet::Resource::TypeCollectionHelper)
-  end
-
   describe "when custom functions are called" do
     let(:env) { Puppet::Node::Environment.create(:testing, []) }
     let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new('foo', :environment => env)) }
@@ -149,7 +154,7 @@ describe Puppet::Parser::Scope do
       expect { @scope[:foo] = 12 }.to raise_error(Puppet::ParseError, /Scope variable name .* not a string/)
     end
 
-    it "should return nil for unset variables" do
+    it "should return nil for unset variables when --strict variables is not in effect" do
       expect(@scope["var"]).to be_nil
     end
 
@@ -192,16 +197,36 @@ describe Puppet::Parser::Scope do
       @scope["var"] = "childval"
       expect {
         @scope["var"] = "change"
-      }.to raise_error(Puppet::Error, "Cannot reassign variable var")
+      }.to raise_error(Puppet::Error, "Cannot reassign variable '$var'")
     end
 
     it "should be able to detect when variables are not set" do
       expect(@scope).not_to be_include("var")
     end
 
+    it "warns and return nil for non found unqualified variable" do
+      Puppet.expects(:warn_once)
+      expect(@scope["santa_clause"]).to be_nil
+    end
+
+    it "warns once for a non found variable" do
+      Puppet.expects(:warning).once
+      expect([@scope["santa_claus"],@scope["santa_claus"]]).to eq([nil, nil])
+    end
+
+    it "warns and return nil for non found qualified variable" do
+      Puppet.expects(:warn_once)
+      expect(@scope["north_pole::santa_clause"]).to be_nil
+    end
+
+    it "does not warn when a numeric variable is missing - they always exist" do
+      Puppet.expects(:warn_once).never
+      expect(@scope["1"]).to be_nil
+    end
+
     describe "and the variable is qualified" do
       before :each do
-        @known_resource_types = @scope.known_resource_types
+        @known_resource_types = @scope.environment.known_resource_types
 
         node      = Puppet::Node.new('localhost')
         @compiler = Puppet::Parser::Compiler.new(node)
@@ -257,17 +282,16 @@ describe Puppet::Parser::Scope do
 
       it "should warn and return nil for qualified variables whose classes have not been evaluated" do
         klass = newclass("other::deep::klass")
-        @scope.expects(:warning)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes do not exist" do
-        @scope.expects(:warning)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should return nil when asked for a non-string qualified variable from a class that does not exist" do
-        @scope.stubs(:warning)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
@@ -296,6 +320,51 @@ describe Puppet::Parser::Scope do
         expect { @scope['module_name'] }.to_not raise_error
       end
     end
+
+    context "and strict_variables is false and --strict=off" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :off
+      end
+
+      it "should not error when unknown variable is looked up and produce nil" do
+        expect(@scope['john_doe']).to be_nil
+      end
+
+      it "should not error when unknown qualified variable is looked up and produce nil" do
+        expect(@scope['nowhere::john_doe']).to be_nil
+      end
+    end
+
+    context "and strict_variables is false and --strict=warning" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
+      end
+
+      it "should not error when unknown variable is looked up" do
+        expect(@scope['john_doe']).to be_nil
+      end
+
+      it "should not error when unknown qualified variable is looked up" do
+        expect(@scope['nowhere::john_doe']).to be_nil
+      end
+    end
+
+    context "and strict_variables is false and --strict=error" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :error
+      end
+
+      it "should raise error when unknown variable is looked up" do
+        expect { @scope['john_doe'] }.to raise_error(/Undefined variable/)
+      end
+
+      it "should not throw a symbol when unknown qualified variable is looked up" do
+        expect { @scope['nowhere::john_doe'] }.to raise_error(/Undefined variable/)
+      end
+    end
   end
 
   describe "when variables are set with append=true" do
@@ -305,7 +374,7 @@ describe Puppet::Parser::Scope do
         @scope.setvar("var", "1", :append => true)
       }.to raise_error(
         Puppet::ParseError,
-        "Cannot append, variable var is defined in this scope"
+        "Cannot append, variable '$var' is defined in this scope"
       )
     end
 
@@ -480,17 +549,15 @@ describe Puppet::Parser::Scope do
         expect(@scope.include?("1")).to be_falsey
       end
 
-      describe "when calling unset_ephemeral_var with a level" do
+      describe "when using a guarded scope" do
         it "should remove ephemeral scopes up to this level" do
           @scope.set_match_data({1 => :value1})
           @scope.new_ephemeral
           @scope.set_match_data({1 => :value2})
-          level = @scope.ephemeral_level()
-          @scope.new_ephemeral
-          @scope.set_match_data({1 => :value3})
-
-          @scope.unset_ephemeral_var(level)
-
+          @scope.with_guarded_scope do
+            @scope.new_ephemeral
+            @scope.set_match_data({1 => :value3})
+          end
           expect(@scope["1"]).to eq(:value2)
         end
       end

data/spec/unit/parser/templatewrapper_spec.rb

@@ -94,7 +94,7 @@ describe Puppet::Parser::TemplateWrapper do
     Puppet::Parser::Files.stubs(:find_template).
       with(name, anything()).
       returns(full_name)
-    File.stubs(:read).with(full_name).returns(contents)
+    Puppet::FileSystem.stubs(:read_preserve_line_endings).with(full_name).returns(contents)
 
     full_name
   end

data/spec/unit/pops/binder/config/binder_config_spec.rb

@@ -16,7 +16,7 @@ describe 'BinderConfig' do
     expect(config.layering_config[0]['name']).to    be == 'site'
     expect(config.layering_config[0]['include']).to be == ['confdir:/default?optional']
     expect(config.layering_config[1]['name']).to    be == 'modules'
-    expect(config.layering_config[1]['include']).to be == ['module:/*::default']
+    expect(config.layering_config[1]['include']).to be == ['module:/*::default', 'module:/*::metadata']
   end
 
   it 'should load binder_config.yaml if it exists in confdir)' do