puppet 4.0.0 → 4.5.0

data/spec/unit/file_system_spec.rb

@@ -5,6 +5,18 @@ require 'puppet/util/platform'
 describe "Puppet::FileSystem" do
   include PuppetSpec::Files
 
+  def with_file_content(content)
+    path = tmpfile('file-system')
+    file = File.new(path, 'wb')
+    file.sync = true
+    file.print content
+
+    yield path
+
+  ensure
+    file.close
+  end
+
   context "#exclusive_open" do
     it "opens ands allows updating of an existing file" do
       file = file_containing("file_to_update", "the contents")
@@ -96,6 +108,58 @@ describe "Puppet::FileSystem" do
     end
   end
 
+  context "read_preserve_line_endings" do
+    it "should read a file with line feed" do
+      with_file_content("file content \n") do |file|
+        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \n")
+      end
+    end
+
+    it "should read a file with carriage return line feed" do
+      with_file_content("file content \r\n") do |file|
+        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \r\n")
+      end
+    end
+
+    it "should read a mixed file using only the first line newline when lf" do
+      with_file_content("file content \nsecond line \r\n") do |file|
+        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \nsecond line \r\n")
+      end
+    end
+
+    it "should read a mixed file using only the first line newline when crlf" do
+      with_file_content("file content \r\nsecond line \n") do |file|
+        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \r\nsecond line \n")
+      end
+    end
+  end
+
+  context "read should allow an encoding to be specified" do
+    # First line of Rune version of Rune poem at http://www.columbia.edu/~fdc/utf8/
+    # characters chosen since they will not parse on Windows with codepage 437 or 1252
+    # Section 3.2.1.3 of Ruby spec guarantees that \u strings are encoded as UTF-8
+    let (:rune_utf8) { "\u16A0\u16C7\u16BB" } # 'ᚠᛇᚻ'
+
+    it "and should read a UTF8 file properly" do
+      temp_file = file_containing('utf8.txt', rune_utf8)
+
+      contents = Puppet::FileSystem.read(temp_file, :encoding => 'utf-8')
+
+      expect(contents.encoding).to eq(Encoding::UTF_8)
+      expect(contents).to eq(rune_utf8)
+    end
+
+    it "does not strip the UTF8 BOM (Byte Order Mark) if present in a file" do
+      bom = "\uFEFF"
+
+      temp_file = file_containing('utf8bom.txt', "#{bom}#{rune_utf8}")
+      contents = Puppet::FileSystem.read(temp_file, :encoding => 'utf-8')
+
+      expect(contents.encoding).to eq(Encoding::UTF_8)
+      expect(contents).to eq("#{bom}#{rune_utf8}")
+    end
+  end
+
   describe "symlink",
     :if => ! Puppet.features.manages_symlinks? &&
     Puppet.features.microsoft_windows? do
@@ -179,6 +243,67 @@ describe "Puppet::FileSystem" do
       end
     end
 
+    it "should return false for exist? when resolving a cyclic symlink chain" do
+      # point symlink -> file
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      # point symlink2 -> symlink
+      symlink2 = tmpfile("somefile_link2")
+      Puppet::FileSystem.symlink(symlink, symlink2)
+
+      # point symlink3 -> symlink2
+      symlink3 = tmpfile("somefile_link3")
+      Puppet::FileSystem.symlink(symlink2, symlink3)
+
+      # yank file, temporarily dangle
+      ::File.delete(file)
+
+      # and trash it so that we can recreate it OK on windows
+      Puppet::FileSystem.unlink(symlink)
+
+      # point symlink -> symlink3 to create a cycle
+      Puppet::FileSystem.symlink(symlink3, symlink)
+
+      expect(Puppet::FileSystem.exist?(symlink3)).to be_falsey
+    end
+
+    it "should return true for exist? when resolving a symlink chain pointing to a file" do
+      # point symlink -> file
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      # point symlink2 -> symlink
+      symlink2 = tmpfile("somefile_link2")
+      Puppet::FileSystem.symlink(symlink, symlink2)
+
+      # point symlink3 -> symlink2
+      symlink3 = tmpfile("somefile_link3")
+      Puppet::FileSystem.symlink(symlink2, symlink3)
+
+      expect(Puppet::FileSystem.exist?(symlink3)).to be_truthy
+    end
+
+    it "should return false for exist? when resolving a symlink chain that dangles" do
+      # point symlink -> file
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      # point symlink2 -> symlink
+      symlink2 = tmpfile("somefile_link2")
+      Puppet::FileSystem.symlink(symlink, symlink2)
+
+      # point symlink3 -> symlink2
+      symlink3 = tmpfile("somefile_link3")
+      Puppet::FileSystem.symlink(symlink2, symlink3)
+
+      # yank file, and make symlink dangle
+      ::File.delete(file)
+
+      # symlink3 is now indirectly dangled
+      expect(Puppet::FileSystem.exist?(symlink3)).to be_falsey
+    end
+
     it "should not create a symlink when the :noop option is specified" do
       [file, dir].each do |target|
         symlink = tmpfile("#{Puppet::FileSystem.basename(target)}_link")
@@ -408,6 +533,26 @@ describe "Puppet::FileSystem" do
       expect(Puppet::FileSystem.readlink(symlink)).to eq(missing_file.to_s)
     end
 
+    it "should be able to unlink a dangling symlink pointed at a file" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+      ::File.delete(file)
+      Puppet::FileSystem.unlink(symlink)
+
+      expect(Puppet::FileSystem).to_not be_exist(file)
+      expect(Puppet::FileSystem).to_not be_exist(symlink)
+    end
+
+    it "should be able to unlink a dangling symlink pointed at a directory" do
+      symlink = tmpfile("somedir_link")
+      Puppet::FileSystem.symlink(dir, symlink)
+      Dir.rmdir(dir)
+      Puppet::FileSystem.unlink(symlink)
+
+      expect(Puppet::FileSystem).to_not be_exist(dir)
+      expect(Puppet::FileSystem).to_not be_exist(symlink)
+    end
+
     it "should delete only the symlink and not the target when calling unlink instance method" do
       [file, dir].each do |target|
         symlink = tmpfile("#{Puppet::FileSystem.basename(target)}_link")

data/spec/unit/functions/assert_type_spec.rb

@@ -1,8 +1,11 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/loaders'
+require 'puppet_spec/compiler'
 
 describe 'the assert_type function' do
+  include PuppetSpec::Compiler
+
   after(:all) { Puppet::Pops::Loaders.clear }
 
   let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
@@ -19,19 +22,17 @@ describe 'the assert_type function' do
   it 'asserts non compliant type by raising an error' do
     expect do
       func.call({}, type(Integer), 'hello world')
-    end.to raise_error(Puppet::Pops::Types::TypeAssertionError, /does not match actual/)
+    end.to raise_error(Puppet::Pops::Types::TypeAssertionError, /expected an Integer value, got String/)
   end
 
   it 'checks that first argument is a type' do
     expect do
       func.call({}, 10, 10)
-    end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
-"function 'assert_type' called with mis-matched arguments
-expected one of:
-  assert_type(Type type, Any value, Callable[Type, Type] block {0,1}) - arg count {2,3}
-  assert_type(String type_string, Any value, Callable[Type, Type] block {0,1}) - arg count {2,3}
-actual:
-  assert_type(Integer, Integer) - arg count {2}")))
+    end.to raise_error(ArgumentError, "'assert_type' expects one of:
+  (Type type, Any value, Callable[Type, Type] block?)
+    rejected: parameter 'type' expects a Type value, got Integer
+  (String type_string, Any value, Callable[Type, Type] block?)
+    rejected: parameter 'type_string' expects a String value, got Integer")
   end
 
   it 'allows the second arg to be undef/nil)' do
@@ -54,4 +55,43 @@ actual:
   def type(type_ref)
     Puppet::Pops::Types::TypeFactory.type_of(type_ref)
   end
+
+  it 'can validate a resource type' do
+    expect(eval_and_collect_notices("assert_type(Type[Resource], File['/tmp/test']) notice('ok')")).to eq(['ok'])
+  end
+
+  it 'can validate a type alias' do
+    code = <<-CODE
+      type UnprivilegedPort = Integer[1024,65537]
+      assert_type(UnprivilegedPort, 5432)
+      notice('ok')
+    CODE
+    expect(eval_and_collect_notices(code)).to eq(['ok'])
+  end
+
+  it 'can validate a type alias passed as a String' do
+    code = <<-CODE
+      type UnprivilegedPort = Integer[1024,65537]
+      assert_type('UnprivilegedPort', 5432)
+      notice('ok')
+    CODE
+    expect(eval_and_collect_notices(code)).to eq(['ok'])
+  end
+
+  it 'can validate and fail using a type alias' do
+    code = <<-CODE
+      type UnprivilegedPort = Integer[1024,65537]
+      assert_type(UnprivilegedPort, 345)
+      notice('ok')
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expected an UnprivilegedPort = Integer\[1024, 65537\] value, got Integer\[345, 345\]/)
+  end
+
+  it 'will use infer_set to report detailed information about complex mismatches' do
+    code = <<-CODE
+      assert_type(Struct[{a=>Integer,b=>Boolean}], {a=>hej,x=>s})
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error,
+      /entry 'a' expected an Integer value, got String.*expected a value for key 'b'.*unrecognized key 'x'/m)
+  end
 end

data/spec/unit/functions/defined_spec.rb

@@ -0,0 +1,289 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe "the 'defined' function" do
+  after(:all) { Puppet::Pops::Loaders.clear }
+
+  # This loads the function once and makes it easy to call it
+  # It does not matter that it is not bound to the env used later since the function
+  # looks up everything via the scope that is given to it.
+  # The individual tests needs to have a fresh env/catalog set up
+  #
+  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
+  let(:func) { loaders.puppet_system_loader.load(:function, 'defined') }
+
+  before :each do
+    # A fresh environment is needed for each test since tests creates types and resources
+    environment = Puppet::Node::Environment.create(:testing, [])
+    @node = Puppet::Node.new('yaynode', :environment => environment)
+    @known_resource_types = environment.known_resource_types
+    @compiler = Puppet::Parser::Compiler.new(@node)
+    @scope = Puppet::Parser::Scope.new(@compiler)
+  end
+
+  def newclass(name)
+    @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
+  end
+
+  def newdefine(name)
+    @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
+  end
+
+  def newresource(type, title)
+    resource = Puppet::Resource.new(type, title)
+    @compiler.add_resource(@scope, resource)
+    resource
+  end
+
+  #--- CLASS
+  #
+  context 'can determine if a class' do
+    context 'is defined' do
+
+      it 'by using the class name in string form' do
+        newclass 'yayness'
+        expect(func.call(@scope, 'yayness')).to be_truthy
+      end
+
+      it 'by using a Type[Class[name]] type reference' do
+        name = 'yayness'
+        newclass name
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(class_type)
+        expect(func.call(@scope, type_type)).to be_truthy
+      end
+    end
+
+    context 'is not defined' do
+      it 'by using the class name in string form' do
+        expect(func.call(@scope, 'yayness')).to be_falsey
+      end
+
+      it 'even if there is a define, by using a Type[Class[name]] type reference' do
+        name = 'yayness'
+        newdefine name
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(class_type)
+        expect(func.call(@scope, type_type)).to be_falsey
+      end
+    end
+
+    context 'is defined and realized' do
+      it 'by using a Class[name] reference' do
+        name = 'cowabunga'
+        newclass name
+        newresource(:class, name)
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        expect(func.call(@scope, class_type)).to be_truthy
+      end
+    end
+
+    context 'is not realized' do
+      it '(although defined) by using a Class[name] reference' do
+        name = 'cowabunga'
+        newclass name
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        expect(func.call(@scope, class_type)).to be_falsey
+      end
+
+      it '(and not defined) by using a Class[name] reference' do
+        name = 'cowabunga'
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        expect(func.call(@scope, class_type)).to be_falsey
+      end
+    end
+  end
+
+  #---RESOURCE TYPE
+  #
+  context 'can determine if a resource type' do
+    context 'is defined' do
+
+      it 'by using the type name (of a built in type) in string form' do
+        expect(func.call(@scope, 'file')).to be_truthy
+      end
+
+      it 'by using the type name (of a resource type) in string form' do
+        newdefine 'yayness'
+        expect(func.call(@scope, 'yayness')).to be_truthy
+      end
+
+      it 'by using a File type reference (built in type)' do
+        resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_truthy
+      end
+
+      it 'by using a Type[File] type reference' do
+        resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_truthy
+      end
+
+      it 'by using a Resource[T] type reference (defined type)' do
+        name = 'yayness'
+        newdefine name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
+        expect(func.call(@scope, resource_type)).to be_truthy
+      end
+
+      it 'by using a Type[Resource[T]] type reference (defined type)' do
+        name = 'yayness'
+        newdefine name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_truthy
+      end
+    end
+
+    context 'is not defined' do
+      it 'by using the resource name in string form' do
+        expect(func.call(@scope, 'notatype')).to be_falsey
+      end
+
+      it 'even if there is a class with the same name, by using a Type[Resource[T]] type reference' do
+        name = 'yayness'
+        newclass name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_falsey
+      end
+    end
+
+    context 'is defined and instance realized' do
+      it 'by using a Resource[T, title] reference for a built in type' do
+        type_name = 'file'
+        title = '/tmp/myfile'
+        newdefine type_name
+        newresource(type_name, title)
+        class_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, class_type)).to be_truthy
+      end
+
+      it 'by using a Resource[T, title] reference for a defined type' do
+        type_name = 'meme'
+        title = 'cowabunga'
+        newdefine type_name
+        newresource(type_name, title)
+        class_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, class_type)).to be_truthy
+      end
+    end
+
+    context 'is not realized' do
+      it '(although defined) by using a Resource[T, title] reference or Type[Resource[T, title]] reference' do
+        type_name = 'meme'
+        title = 'cowabunga'
+        newdefine type_name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, resource_type)).to be_falsey
+
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_falsey
+      end
+
+      it '(and not defined) by using a Resource[T, title] reference or Type[Resource[T, title]] reference' do
+        type_name = 'meme'
+        title = 'cowabunga'
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, resource_type)).to be_falsey
+
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_falsey
+      end
+    end
+  end
+
+  #---VARIABLES
+  #
+  context 'can determine if a variable' do
+    context 'is defined' do
+      it 'by giving the variable in string form' do
+        @scope['x'] = 'something'
+        expect(func.call(@scope, '$x')).to be_truthy
+      end
+
+      it 'by giving a :: prefixed variable in string form' do
+        @compiler.topscope['x'] = 'something'
+        expect(func.call(@scope, '$::x')).to be_truthy
+      end
+
+      it 'by giving a numeric variable in string form (when there is a match scope)' do
+        # with no match scope, there are no numeric variables defined
+        expect(func.call(@scope, '$0')).to be_falsey
+        expect(func.call(@scope, '$42')).to be_falsey
+        pattern = Regexp.new('.*')
+        @scope.new_match_scope(pattern.match('anything'))
+
+        # with a match scope, all numeric variables are set (the match defines if they have a value or not, but they are defined)
+        # even if their value is undef.
+        expect(func.call(@scope, '$0')).to be_truthy
+        expect(func.call(@scope, '$42')).to be_truthy
+      end
+    end
+
+    context 'is undefined' do
+      it 'by giving a :: prefixed or regular variable in string form' do
+        expect(func.call(@scope, '$x')).to be_falsey
+        expect(func.call(@scope, '$::x')).to be_falsey
+      end
+    end
+  end
+
+  context 'has any? semantics when given multiple arguments' do
+    it 'and one of the names is a defined user defined type' do
+      newdefine 'yayness'
+      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_truthy
+    end
+
+    it 'and one of the names is a built type' do
+      expect(func.call(@scope, 'meh', 'file', 'booness')).to be_truthy
+    end
+
+    it 'and one of the names is a defined class' do
+      newclass 'yayness'
+      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_truthy
+    end
+
+    it 'is true when at least one variable exists in scope' do
+      @scope['x'] = 'something'
+      expect(func.call(@scope, '$y', '$x', '$z')).to be_truthy
+    end
+
+    it 'is false when none of the names are defined' do
+      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_falsey
+    end
+  end
+
+  it 'raises an argument error when asking if Resource type is defined' do
+    resource_type = Puppet::Pops::Types::TypeFactory.resource
+    expect { func.call(@scope, resource_type)}.to raise_error(ArgumentError, /reference to all.*type/)
+  end
+
+  it 'raises an argument error if you ask if Class is defined' do
+    class_type = Puppet::Pops::Types::TypeFactory.host_class
+    expect { func.call(@scope, class_type) }.to raise_error(ArgumentError, /reference to all.*class/)
+  end
+
+  it 'raises error if referencing undef' do
+    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String or Type, got Undef/)
+  end
+
+  it 'raises error if referencing a number' do
+    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String or Type, got Integer/)
+  end
+
+  it 'is false if referencing empty string' do
+    expect(func.call(@scope, '')).to be_falsey
+  end
+
+  it "is true if referencing 'main'" do
+    # mimic what compiler does with "main" in intial import
+    newclass ''
+    newresource :class, ''
+    expect(func.call(@scope, 'main')).to be_truthy
+  end
+
+end

data/spec/unit/functions/dig_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the dig function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'returns a value from an array index via integer index' do
+    expect(compile_to_catalog("notify { [testing].dig(0): }")).to have_resource('Notify[testing]')
+  end
+
+  it 'returns undef if given an undef key' do
+  expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test-Undef-ing]')
+    notify { "test-${type([testing].dig(undef))}-ing": }
+    SOURCE
+  end
+
+  it 'returns undef if starting with undef' do
+  expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test-Undef-ing]')
+    notify { "test-${type(undef.dig(undef))}-ing": }
+    SOURCE
+  end
+
+  it 'returns a value from an hash key via given key' do
+    expect(compile_to_catalog("notify { {key => testing}.dig(key): }")).to have_resource('Notify[testing]')
+  end
+
+  it 'continues digging if result is an array' do
+    expect(compile_to_catalog("notify { [nope, [testing]].dig(1, 0): }")).to have_resource('Notify[testing]')
+  end
+
+  it 'continues digging if result is a hash' do
+    expect(compile_to_catalog("notify { [nope, {yes => testing}].dig(1, yes): }")).to have_resource('Notify[testing]')
+  end
+
+  it 'stops digging when step is undef' do
+    expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[testing]')
+    $result = [nope, {yes => testing}].dig(1, no, 2)
+    notify { "test${result}ing": }
+    SOURCE
+  end
+
+  it 'errors if step is neither Array nor Hash' do
+    expect { compile_to_catalog(<<-SOURCE)}.to raise_error(/The given data does not contain a Collection at \[1, "yes"\], got 'String'/)
+    $result = [nope, {yes => testing}].dig(1, yes, 2)
+    notify { "test${result}ing": }
+    SOURCE
+  end
+
+  it 'errors if not given a non Collection as the starting point' do
+    expect { compile_to_catalog(<<-SOURCE)}.to raise_error(/'dig' parameter 'data' expects a Collection value, got String/)
+    "hello".dig(1, yes, 2)
+    SOURCE
+  end
+
+end

data/spec/unit/functions/epp_spec.rb

@@ -5,7 +5,7 @@ describe "the epp function" do
 
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
-  let :scope    do Puppet::Parser::Scope.new(compiler) end
+  let :scope    do compiler.topscope end
 
   context "when accessing scope variables as $ variables" do
     it "looks up the value from the scope" do
@@ -27,11 +27,19 @@ describe "the epp function" do
       expect(eval_template_with_args("<%= $phantom == dragos %>", 'phantom' => 'dragos')).to eq("true")
     end
 
-    it "can use values from the enclosing scope for defaults" do
+    it "can use values from the global scope for defaults" do
       scope['phantom'] = 'of the opera'
-      expect(eval_template("<%- |$phantom = $phantom| -%><%= $phantom %>")).to eq("of the opera")
+      expect(eval_template("<%- |$phantom = $::phantom| -%><%= $phantom %>")).to eq("of the opera")
     end
 
+    it "will not use values from the enclosing scope for defaults" do
+      scope['the_phantom'] = 'of the state opera'
+      scope.new_ephemeral(true)
+      scope['the_phantom'] = 'of the local opera'
+      expect(scope['the_phantom']).to eq('of the local opera')
+      expect(eval_template("<%- |$phantom = $the_phantom| -%><%= $phantom %>")).to eq("of the state opera")
+     end
+
     it "uses the default value if the given value is undef/nil" do
       expect(eval_template_with_args("<%- |$phantom = 'inside your mind'| -%><%= $phantom %>", 'phantom' => nil)).to eq("inside your mind")
     end
@@ -44,15 +52,15 @@ describe "the epp function" do
     it "raises an error if required variable is not given" do
       scope['x'] = 'wrong one'
       expect do
-        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'y' => 'correct')
-      end.to raise_error(/no value given for required parameters x/)
+        eval_template("<%-| $x |-%><%= $x == correct %>")
+      end.to raise_error(/expects a value for parameter 'x'/)
     end
 
-    it "raises an error if too many arguments are given" do
+    it 'raises an error if invalid arguments are given' do
       scope['x'] = 'wrong one'
       expect do
         eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct', 'y' => 'surplus')
-      end.to raise_error(/Too many arguments: 2 for 1/)
+      end.to raise_error(/has no parameter named 'y'/)
     end
   end
 
@@ -80,13 +88,13 @@ describe "the epp function" do
     it "raises an error when the passed value does not match the parameter's type" do
       expect do
         eval_template_with_args("<%-|Integer $x|-%><%= $x %>", 'x' => 'incorrect')
-      end.to raise_error(/expected.*Integer.*actual.*String/m)
+      end.to raise_error(/parameter 'x' expects an Integer value, got String/)
     end
 
     it "raises an error when the default value does not match the parameter's type" do
       expect do
         eval_template("<%-|Integer $x = 'nope'|-%><%= $x %>")
-      end.to raise_error(/expected.*Integer.*actual.*String/m)
+      end.to raise_error(/parameter 'x' expects an Integer value, got String/)
     end
 
     it "allows an parameter to default to undef" do