puppet 4.2.0 → 4.3.0

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -0,0 +1,201 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe "when using a hiera data provider" do
+  include PuppetSpec::Compiler
+
+  # There is a fully configured 'sample' environment in fixtures at this location
+  let(:environmentpath) { parent_fixture('environments') }
+
+  let(:facts) { Puppet::Node::Facts.new("facts", {}) }
+
+  around(:each) do |example|
+    # Initialize settings to get a full compile as close as possible to a real
+    # environment load
+    Puppet.settings.initialize_global_settings
+    # Initialize loaders based on the environmentpath. It does not work to
+    # just set the setting environmentpath for some reason - this achieves the same:
+    # - first a loader is created, loading directory environments from the fixture (there is
+    # one environment, 'sample', which will be loaded since the node references this
+    # environment by name).
+    # - secondly, the created env loader is set as 'environments' in the puppet context.
+    #
+    loader = Puppet::Environments::Directories.new(environmentpath, [])
+    Puppet.override(:environments => loader) do
+      example.run
+    end
+  end
+
+  def compile_and_get_notifications(environment, code = nil)
+    compile(environment, code).resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
+  end
+
+  def compile(environment, code = nil)
+    Puppet[:code] = code if code
+    node = Puppet::Node.new("testnode", :facts => facts, :environment => environment)
+    compiler = Puppet::Parser::Compiler.new(node)
+    block_given? ? compiler.compile() { |catalog| yield(compiler); catalog } : compiler.compile()
+  end
+
+  it 'uses default configuration for environment and module data' do
+    resources = compile_and_get_notifications('hiera_defaults')
+    expect(resources).to include('module data param_a is 100, param default is 200, env data param_c is 300')
+  end
+
+  it 'reads hiera.yaml in environment root and configures multiple json and yaml providers' do
+    resources = compile_and_get_notifications('hiera_env_config')
+    expect(resources).to include('env data param_a is 10, env data param_b is 20, env data param_c is 30, env data param_d is 40, env data param_e is 50')
+  end
+
+  it 'reads hiera.yaml in module root and configures multiple json and yaml providers' do
+    resources = compile_and_get_notifications('hiera_module_config')
+    expect(resources).to include('module data param_a is 100, module data param_b is 200, module data param_c is 300, module data param_d is 400, module data param_e is 500')
+  end
+
+  it 'does not perform merge of values declared in environment and module when resolving parameters' do
+    resources = compile_and_get_notifications('hiera_misc')
+    expect(resources).to include('env 1, ')
+  end
+
+  it 'performs hash merge of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', '$r = lookup(one::test::param, Hash[String,String], hash) notify{"${r[key1]}, ${r[key2]}":}')
+    expect(resources).to include('env 1, module 2')
+  end
+
+  it 'performs unique merge of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', '$r = lookup(one::array, Array[String], unique) notify{"${r}":}')
+    expect(resources.size).to eq(1)
+    expect(resources[0][1..-2].split(', ')).to contain_exactly('first', 'second', 'third', 'fourth')
+  end
+
+  it 'performs merge found in lookup_options in environment of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', 'include one::lopts_test')
+    expect(resources.size).to eq(1)
+    expect(resources[0]).to eq('A, B, C, MA, MB, MC')
+  end
+
+  it 'performs merge found in lookup_options in module of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', 'include one::loptsm_test')
+    expect(resources.size).to eq(1)
+    expect(resources[0]).to eq('A, B, C, MA, MB, MC')
+  end
+
+  it "can lookup the 'lookup_options' hash as a regular value" do
+    resources = compile_and_get_notifications('hiera_misc', '$r = lookup(lookup_options, Hash[String,Hash[String,String]], hash) notify{"${r[one::lopts_test::hash][merge]}":}')
+    expect(resources.size).to eq(1)
+    expect(resources[0]).to eq('deep')
+  end
+
+  it 'does find unqualified keys in the environment' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(ukey1):}')
+    expect(resources).to include('Some value')
+  end
+
+  it 'does not find unqualified keys in the module' do
+    expect do
+      compile_and_get_notifications('hiera_misc', 'notify{lookup(ukey2):}')
+    end.to raise_error(Puppet::ParseError, /did not find a value for the name 'ukey2'/)
+  end
+
+  it 'can use interpolation lookup method "alias"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_alias):}')
+    expect(resources).to include('Value from interpolation with alias')
+  end
+
+  it 'can use interpolation lookup method "lookup"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_lookup):}')
+    expect(resources).to include('Value from interpolation with lookup')
+  end
+
+  it 'can use interpolation lookup method "hiera"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_hiera):}')
+    expect(resources).to include('Value from interpolation with hiera')
+  end
+
+  it 'can use interpolation lookup method "literal"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_literal):}')
+    expect(resources).to include('Value from interpolation with literal')
+  end
+
+  it 'can use interpolation lookup method "scope"' do
+    resources = compile_and_get_notifications('hiera_misc', '$target_scope = "with scope" notify{lookup(km_scope):}')
+    expect(resources).to include('Value from interpolation with scope')
+  end
+
+  it 'can use interpolation using default lookup method (scope)' do
+    resources = compile_and_get_notifications('hiera_misc', '$target_default = "with default" notify{lookup(km_default):}')
+    expect(resources).to include('Value from interpolation with default')
+  end
+
+  it 'performs lookup using qualified expressions in interpolation' do
+    resources = compile_and_get_notifications('hiera_misc', "$os = { name => 'Fedora' } notify{lookup(km_qualified):}")
+    expect(resources).to include('Value from qualified interpolation OS = Fedora')
+  end
+
+  it 'can have multiple interpolate expressions in one value' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_multi):}')
+    expect(resources).to include('cluster/%{::cluster}/%{role}')
+  end
+
+  it 'performs single quoted interpolation' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_sqalias):}')
+    expect(resources).to include('Value from interpolation with alias')
+  end
+
+  it 'traps endless interpolate recursion' do
+    expect do
+      compile_and_get_notifications('hiera_misc', '$r1 = "%{r2}" $r2 = "%{r1}" notify{lookup(recursive):}')
+    end.to raise_error(Puppet::DataBinding::RecursiveLookupError, /detected in \[recursive, r1, r2\]/)
+  end
+
+  it 'traps bad alias declarations' do
+    expect do
+      compile_and_get_notifications('hiera_misc', "$r1 = 'Alias within string %{alias(\"r2\")}' $r2 = '%{r1}' notify{lookup(recursive):}")
+    end.to raise_error(Puppet::DataBinding::LookupError, /'alias' interpolation is only permitted if the expression is equal to the entire string/)
+  end
+
+  it 'reports syntax errors for JSON files' do
+    expect do
+      compile_and_get_notifications('hiera_bad_syntax_json')
+    end.to raise_error(Puppet::DataBinding::LookupError, /Unable to parse \(#{environmentpath}[^)]+\):/)
+  end
+
+  it 'reports syntax errors for YAML files' do
+    expect do
+      compile_and_get_notifications('hiera_bad_syntax_yaml')
+    end.to raise_error(Puppet::DataBinding::LookupError, /Unable to parse \(#{environmentpath}[^)]+\):/)
+  end
+
+  describe 'when using explain' do
+    it 'will report config path (original and resolved), data path (original and resolved), and interpolation (before and after)' do
+      compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
+        value = Puppet::Pops::Lookup.lookup('km_scope', nil, nil, nil, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "km_scope"
+  Data Provider "Hiera Data Provider, version 4"
+    ConfigurationPath "#{environmentpath}/hiera_misc/hiera.yaml"
+    Data Provider "common"
+      Path "#{environmentpath}/hiera_misc/data/common.yaml"
+        Original path: common
+        Interpolation on "Value from interpolation %{scope("target_scope")}"
+          Global Scope"
+            Found key: "target_scope" value: "with scope"
+        Found key: "km_scope" value: "Value from interpolation with scope"
+  Merged result: "Value from interpolation with scope"
+EOS
+      end
+    end
+  end
+  def parent_fixture(dir_name)
+    File.absolute_path(File.join(my_fixture_dir(), "../#{dir_name}"))
+  end
+
+  def resources_in(catalog)
+    catalog.resources.map(&:ref)
+  end
+
+end

data/spec/unit/environments_spec.rb

@@ -642,6 +642,8 @@ config_version=$vardir/random/scripts
     end
 
     def expired?(env_name)
+      # make expired? idempotent
+      return true if @expired_envs.include? (env_name)
       @expired_envs << env_name
       @expiration_sequence.pop
     end

data/spec/unit/face/node_spec.rb

@@ -47,7 +47,7 @@ describe Puppet::Face[:node, '0.0.1'] do
     end
 
     it "should not accept a call with no arguments" do
-      expect { subject.clean() }.to raise_error
+      expect { subject.clean() }.to raise_error(RuntimeError, /At least one node should be passed/)
     end
 
     it "should accept a node name" do

data/spec/unit/file_bucket/dipper_spec.rb

@@ -72,6 +72,216 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     expect { @dipper.backup(file) }.to raise_error(Puppet::Error)
   end
 
+  describe "when diffing on a local filebucket" do
+    describe "in non-windows environments", :unless => Puppet.features.microsoft_windows? do
+      with_digest_algorithms do
+
+        it "should fail in an informative way when one or more checksum doesn't exists" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
+          wrong_checksum = "DEADBEEF"
+
+          # First checksum fails
+          expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(RuntimeError, "Invalid checksum #{wrong_checksum.inspect}")
+
+          file = make_tmp_file(plaintext)
+          @dipper.backup(file)
+
+          #Diff_with checksum fails
+          expect { @dipper.diff(checksum, wrong_checksum, nil, nil) }.to raise_error(RuntimeError, "could not find diff_with #{wrong_checksum}")
+        end
+
+        it "should properly diff files on the filebucket" do
+          file1 = make_tmp_file("OriginalContent")
+          file2 = make_tmp_file("ModifiedContent")
+          @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
+          checksum1 = @dipper.backup(file1)
+          checksum2 = @dipper.backup(file2)
+
+          # Diff without the context
+          diff12 = `diff -uN #{file1} #{file2} | sed '1,2d'`
+          diff21 = `diff -uN #{file2} #{file1} | sed '1,2d'`
+
+          expect(@dipper.diff(checksum1, checksum2, nil, nil)).to include(diff12)
+          expect(@dipper.diff(checksum1, nil, nil, file2)).to include(diff12)
+          expect(@dipper.diff(nil, checksum2, file1, nil)).to include(diff12)
+          expect(@dipper.diff(nil, nil, file1, file2)).to include(diff12)
+          expect(@dipper.diff(checksum2, checksum1, nil, nil)).to include(diff21)
+          expect(@dipper.diff(checksum2, nil, nil, file1)).to include(diff21)
+          expect(@dipper.diff(nil, checksum1, file2, nil)).to include(diff21)
+          expect(@dipper.diff(nil, nil, file2, file1)).to include(diff21)
+
+        end
+      end
+      describe "in windows environment", :if => Puppet.features.microsoft_windows? do
+        it "should fail in an informative way when trying to diff" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
+          wrong_checksum = "DEADBEEF"
+
+          # First checksum fails
+          expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+
+          # Diff_with checksum fails
+          expect { @dipper.diff(checksum, wrong_checksum, nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+        end
+      end
+    end
+  end
+  it "should fail in an informative way when there are failures listing files on the server" do
+    @dipper = Puppet::FileBucket::Dipper.new(:Path => "/unexistent/bucket")
+    Puppet::FileBucket::File.indirection.expects(:find).returns nil
+
+    expect { @dipper.list(nil, nil) }.to raise_error(Puppet::Error)
+  end
+
+  describe "listing files in local filebucket" do
+    with_digest_algorithms do
+      it "should list all files present" do
+        Puppet[:bucketdir] =  "/my/bucket"
+        file_bucket = tmpdir("bucket")
+
+        @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
+
+        onehour=60*60
+        twohours=onehour*2
+
+        #First File
+        file1 = make_tmp_file(plaintext)
+        real_path = Pathname.new(file1).realpath
+        expect(digest(plaintext)).to eq(checksum)
+        expect(@dipper.backup(file1)).to eq(checksum)
+        expected_list1_1 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        File.open(file1, 'w') {|f| f.write("Blahhhh")}
+        new_checksum = digest("Blahhhh")
+        expect(@dipper.backup(file1)).to eq(new_checksum)
+        expected_list1_2 = /#{new_checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        #Second File
+        content = "DummyFileWithNonSenseTextInIt"
+        file2 = make_tmp_file(content)
+        real_path = Pathname.new(file2).realpath
+        checksum = digest(content)
+        expect(@dipper.backup(file2)).to eq(checksum)
+        expected_list2 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        #Third file : Same as the first one with a different path
+        file3 = make_tmp_file(plaintext)
+        real_path = Pathname.new(file3).realpath
+        checksum = digest(plaintext)
+        expect(digest(plaintext)).to eq(checksum)
+        expect(@dipper.backup(file3)).to eq(checksum)
+        date = Time.now
+        expected_list3 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        result = @dipper.list(nil, nil)
+        expect(result).to match(expected_list1_1)
+        expect(result).to match(expected_list1_2)
+        expect(result).to match(expected_list2)
+        expect(result).to match(expected_list3)
+      end
+
+      it "should filter with the provided dates" do
+        Puppet[:bucketdir] =  "/my/bucket"
+        file_bucket = tmpdir("bucket")
+
+        twentyminutes=60*20
+        thirtyminutes=60*30
+        onehour=60*60
+        twohours=onehour*2
+        threehours=onehour*3
+
+        # First File created now
+        @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
+        file1 = make_tmp_file(plaintext)
+        real_path = Pathname.new(file1).realpath
+
+        expect(digest(plaintext)).to eq(checksum)
+        expect(@dipper.backup(file1)).to eq(checksum)
+        expected_list1 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        # Second File created an hour ago
+        content = "DummyFileWithNonSenseTextInIt"
+        file2 = make_tmp_file(content)
+        real_path = Pathname.new(file2).realpath
+        checksum = digest(content)
+        expect(@dipper.backup(file2)).to eq(checksum)
+
+        # Modify mtime of the second file to be an hour ago
+        onehourago = Time.now - onehour
+        bucketed_paths_file = Dir.glob("#{file_bucket}/**/#{checksum}/paths")
+        FileUtils.touch(bucketed_paths_file, :mtime => onehourago)
+        expected_list2 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        now = Time.now
+
+        #Future
+        expect(@dipper.list((now + threehours).strftime("%F %T"), nil )).to eq("")
+
+        #Epoch -> Future = Everything (Sorted (desc) by date)
+        expect(@dipper.list(nil, (now + twohours).strftime("%F %T"))).to match(expected_list1)
+        expect(@dipper.list(nil, (now + twohours).strftime("%F %T"))).to match(expected_list2)
+
+        #Now+1sec -> Future = Nothing
+        expect(@dipper.list((now + 1).strftime("%F %T"), (now + twohours).strftime("%F %T"))).to eq("")
+
+        #Now-30mins -> Now-20mins = Nothing
+        expect(@dipper.list((now - thirtyminutes).strftime("%F %T"), (now - twentyminutes).strftime("%F %T"))).to eq("")
+
+        #Now-2hours -> Now-30mins = Second file only
+        expect(@dipper.list((now - twohours).strftime("%F %T"), (now - thirtyminutes).strftime("%F %T"))).to match(expected_list2)
+        expect(@dipper.list((now - twohours).strftime("%F %T"), (now - thirtyminutes).strftime("%F %T"))).not_to match(expected_list1)
+
+        #Now-30minutes -> Now = First file only
+        expect(@dipper.list((now - thirtyminutes).strftime("%F %T"), now.strftime("%F %T"))).to match(expected_list1)
+        expect(@dipper.list((now - thirtyminutes).strftime("%F %T"), now.strftime("%F %T"))).not_to match(expected_list2)
+      end
+    end
+  end
+
+  describe "when diffing on a remote filebucket" do
+    describe "in non-windows environments", :unless => Puppet.features.microsoft_windows? do
+      with_digest_algorithms do
+        it "should fail in an informative way when one or more checksum doesn't exists" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+          wrong_checksum = "DEADBEEF"
+
+          Puppet::FileBucketFile::Rest.any_instance.expects(:find).returns(nil)
+          expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(Puppet::Error, "Failed to diff files")
+
+        end
+
+        it "should properly diff files on the filebucket" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+
+          Puppet::FileBucketFile::Rest.any_instance.expects(:find).returns("Probably valid diff")
+
+          expect(@dipper.diff("checksum1", "checksum2", nil, nil)).to eq("Probably valid diff")
+        end
+      end
+    end
+
+    describe "in windows environment", :if => Puppet.features.microsoft_windows? do
+      it "should fail in an informative way when trying to diff" do
+        @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+        wrong_checksum = "DEADBEEF"
+
+        expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+
+        expect { @dipper.diff(wrong_checksum, nil, nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+      end
+    end
+  end
+
+  describe "listing files in remote filebucket" do
+    it "is not allowed" do
+      @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port=> "31337")
+
+      expect {
+        @dipper.list(nil, nil)
+      }.to raise_error(Puppet::Error, "Listing remote file buckets is not allowed")
+    end
+  end
+
   describe "backing up and retrieving local files" do
     with_digest_algorithms do
       it "should backup files to a local bucket" do
@@ -173,4 +383,3 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     end
   end
 end
-

data/spec/unit/file_serving/configuration_spec.rb

@@ -17,7 +17,7 @@ describe Puppet::FileServing::Configuration do
   end
 
   it "should make :new a private method" do
-    expect { Puppet::FileServing::Configuration.new }.to raise_error
+    expect { Puppet::FileServing::Configuration.new }.to raise_error(NoMethodError, /private method `new' called/)
   end
 
   it "should return the same configuration each time 'configuration' is called" do

data/spec/unit/file_system_spec.rb

@@ -446,6 +446,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

@@ -25,13 +25,11 @@ describe 'the assert_type function' do
   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' expected 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

data/spec/unit/functions/defined_spec.rb

@@ -268,11 +268,11 @@ describe "the 'defined' function" do
   end
 
   it 'raises error if referencing undef' do
-    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /mis-matched arguments/)
+    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String, Type\[CatalogEntry\], or Type\[Type\[CatalogEntry\]\], got Undef/)
   end
 
   it 'raises error if referencing a number' do
-    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /mis-matched arguments/)
+    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String, Type\[CatalogEntry\], or Type\[Type\[CatalogEntry\]\], got Integer/)
   end
 
   it 'is false if referencing empty string' do

data/spec/unit/functions/epp_spec.rb

@@ -80,13 +80,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(/block 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(/block parameter 'x' expects an Integer value, got String/)
     end
 
     it "allows an parameter to default to undef" do

data/spec/unit/functions/filter_spec.rb

@@ -122,6 +122,24 @@ describe 'the filter method' do
     expect(catalog).to have_resource("File[/file_blueb]").with_parameter(:ensure, 'present')
   end
 
+  it 'filters on an array will not include elements for which the block returns truthy but not true' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $r = [1, 2, 3].filter |$v| { $v } == []
+      notify { "eval_${$r}": }
+    MANIFEST
+
+    expect(catalog).to have_resource('Notify[eval_true]')
+  end
+
+  it 'filters on a hash will not include elements for which the block returns truthy but not true' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $r = {a => 1, b => 2, c => 3}.filter |$k, $v| { $v } == {}
+      notify { "eval_${$r}": }
+    MANIFEST
+
+    expect(catalog).to have_resource('Notify[eval_true]')
+  end
+
   it_should_behave_like 'all iterative functions argument checks', 'filter'
   it_should_behave_like 'all iterative functions hash handling', 'filter'
 end

data/spec/unit/functions/hiera_spec.rb

@@ -108,7 +108,7 @@ describe 'when calling' do
 
     it 'should use the array resolution_type' do
       Hiera.any_instance.expects(:lookup).with { |*args| expect(args[4]).to be(:array) }.returns(%w[foo bar baz])
-      hiera_include.expects(:call_function).with('include', %w[foo bar baz])
+      hiera_include.expects(:call_function_with_scope).with(scope, 'include', %w[foo bar baz])
       hiera_include.call(scope, 'key', {'key' => 'foo_result'})
     end
 
@@ -118,7 +118,7 @@ describe 'when calling' do
     end
 
     it 'should use default block' do
-      hiera_include.expects(:call_function).with('include', %w[key foo])
+      hiera_include.expects(:call_function_with_scope).with(scope,'include', %w[key foo])
       hiera_include.call(scope, 'foo') { |k| ['key', k] }
     end
   end