puppet 4.0.0 → 4.5.0

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

@@ -26,18 +26,20 @@ describe 'when calling' do
       expect(hiera.call(scope, 'key')).to eql('foo_result')
     end
 
-    it 'should propagate optional default' do
-      dflt = 'the_default'
-      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[1]).to be(dflt) }.returns('foo_result')
-      expect(hiera.call(scope, 'key', dflt)).to eql('foo_result')
-    end
-
     it 'should propagate optional override' do
       ovr = 'the_override'
       Hiera.any_instance.expects(:lookup).with { |*args| expect(args[3]).to be(ovr) }.returns('foo_result')
       expect(hiera.call(scope, 'key', nil, ovr)).to eql('foo_result')
     end
 
+    it 'should return default value nil when key is not found' do
+       expect(hiera.call(scope, 'foo', nil)).to be_nil
+    end
+
+    it "should return default value '' when key is not found" do
+      expect(hiera.call(scope, 'foo', '')).to eq('')
+    end
+
     it 'should use default block' do
       #expect(hiera.call(scope, 'foo', lambda_1(scope, loader) { |k| "default for key '#{k}'" })).to eql("default for key 'foo'")
       expect(hiera.call(scope, 'foo') { |k| "default for key '#{k}'" }).to eql("default for key 'foo'")
@@ -106,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
 
@@ -116,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

data/spec/unit/functions/inline_epp_spec.rb

@@ -36,15 +36,15 @@ describe "the inline_epp function" do
     it "raises an error if required variable is not given" do
       scope['x'] = 'wrong one'
       expect {
-        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'y' => 'correct')
-      }.to raise_error(/no value given for required parameters x/)
+        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", {})
+      }.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 unexpected arguments are given' do
       scope['x'] = 'wrong one'
       expect {
         eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct', 'y' => 'surplus')
-      }.to raise_error(/Too many arguments: 2 for 1/)
+      }.to raise_error(/has no parameter named 'y'/)
     end
   end
 

data/spec/unit/functions/lest_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the lest function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'calls a lambda passing no argument' do
+    expect(compile_to_catalog("lest(undef) || { notify { testing: } }")).to have_resource('Notify[testing]')
+  end
+
+  it 'produces what lambda returns if value is undef' do
+    expect(compile_to_catalog("notify{ lest(undef) || { testing }: }")).to have_resource('Notify[testing]')
+  end
+
+  it 'does not call lambda if argument is not undef' do
+    expect(compile_to_catalog('lest(1) || { notify { "failed": } }')).to_not have_resource('Notify[failed]')
+  end
+
+  it 'produces given argument if given not undef' do
+    expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test_yay_ing]')
+    notify{ "test${lest('_yay_') || { '_oh_no_' }}ing": }
+    SOURCE
+  end
+
+  it 'errors when lambda wants too many args' do
+    expect do
+      compile_to_catalog('lest(1) |$x| { }')
+    end.to raise_error(/'lest' block expects no arguments, got 1/m)
+  end
+
+end

data/spec/unit/functions/lookup_spec.rb

@@ -27,19 +27,24 @@ describe "when performing lookup" do
   # @param *args [String] splat of args that will be concatenated to form the puppet args sent to lookup
   # @return [Array<String>] List of names of Notify resources in the resulting catalog
   #
-  def assemble_and_compile(fmt, *lookup_args)
-    assemble_and_compile_with_block(fmt, "'no_block_present'", *lookup_args)
+  def assemble_and_compile(fmt, *lookup_args, &block)
+    assemble_and_compile_with_block(fmt, "'no_block_present'", *lookup_args, &block)
   end
 
-  def assemble_and_compile_with_block(fmt, block, *lookup_args)
-    Puppet[:code] = <<-END.gsub(/^ {6}/, '')
+  def assemble_and_compile_with_block(fmt, block, *lookup_args, &cblock)
+    compile_and_get_notifications(<<-END.gsub(/^ {6}/, ''), &cblock)
       $args = [#{lookup_args.join(',')}]
       $block = #{block}
       include abc
       $r = if $abc::result == undef { 'no_value' } else { $abc::result }
       notify { \"#{fmt}\": }
     END
-    compiler.compile().resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
+  end
+
+  def compile_and_get_notifications(code)
+    Puppet[:code] = code
+    catalog = block_given? ? compiler.compile { |catalog| yield(compiler.topscope); catalog } : compiler.compile
+    catalog.resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
   end
 
   # There is a fully configured 'production' environment in fixtures at this location
@@ -76,7 +81,18 @@ describe "when performing lookup" do
       expect(resources).to include('module_b')
     end
 
+    it "can lookup value provided by the module that has 'function' data_provider entry in metadata.json" do
+      resources = compile_and_get_notifications("$args = ['meta::b']\ninclude meta\nnotify { $meta::result: }\n")
+      expect(resources).to include('module_b')
+    end
+
+    it "can lookup value provided by the module that has 'sample' data_provider entry in metadata.json" do
+      resources = compile_and_get_notifications("$args = ['metawcp::b']\ninclude metawcp\nnotify { $metawcp::result: }\n")
+      expect(resources).to include('module_b')
+    end
+
     it 'can lookup value provided in global scope' do
+      Hiera.any_instance.expects(:lookup).with('lookup_options', any_parameters).at_most_once.throws(:no_such_key)
       Hiera.any_instance.expects(:lookup).with('abc::a', any_parameters).returns('global_a')
       resources = assemble_and_compile('${r}', "'abc::a'")
       expect(resources).to include('global_a')
@@ -108,6 +124,7 @@ describe "when performing lookup" do
     end
 
     it "can 'hash' merge values provided by global, environment, and module" do
+      Hiera.any_instance.expects(:lookup).with('lookup_options', any_parameters).at_most_once.throws(:no_such_key)
       Hiera.any_instance.expects(:lookup).with('abc::e', any_parameters).returns({ 'k1' => 'global_e1' })
       resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::e'", 'Hash[String,String]', "'hash'")
       expect(resources).to include('global_e1_module_e2_env_e3')
@@ -153,7 +170,7 @@ describe "when performing lookup" do
     it 'will not accept a succesful lookup of an undef value when the type rejects it' do
       expect do
         assemble_and_compile('${r}', "'abc::n'", 'String')
-      end.to raise_error(Puppet::ParseError, /found value has wrong type/)
+      end.to raise_error(Puppet::ParseError, /Found value had wrong type, expected a String value, got Undef/)
     end
 
     it 'will raise an exception when value is not found for array key and no default is provided' do
@@ -173,30 +190,35 @@ describe "when performing lookup" do
     end
 
     it 'can lookup and deep merge deep values provided by global, environment, and module' do
+      Hiera.any_instance.expects(:lookup).with('lookup_options', any_parameters).at_most_once.throws(:no_such_key)
       Hiera.any_instance.expects(:lookup).with('abc::f', any_parameters).returns({ 'k1' => { 's1' => 'global_f11' }, 'k2' => { 's3' => 'global_f23' }})
       resources = assemble_and_compile('${r[k1][s1]}_${r[k1][s2]}_${r[k1][s3]}_${r[k2][s1]}_${r[k2][s2]}_${r[k2][s3]}', "'abc::f'", 'Hash[String,Hash[String,String]]', "'deep'")
       expect(resources).to include('global_f11_env_f12_module_f13_env_f21_module_f22_global_f23')
     end
 
     it 'will propagate resolution_type :array to Hiera when merge == \'unique\''  do
+      Hiera.any_instance.expects(:lookup).with('lookup_options', any_parameters).at_most_once.throws(:no_such_key)
       Hiera.any_instance.expects(:lookup).with('abc::c', anything, anything, anything, :array).returns(['global_c'])
       resources = assemble_and_compile('${r[0]}_${r[1]}_${r[2]}', "'abc::c'", 'Array[String]', "'unique'")
       expect(resources).to include('global_c_env_c_module_c')
     end
 
     it 'will propagate a Hash resolution_type with :behavior => :native to Hiera when merge == \'hash\''  do
+      Hiera.any_instance.expects(:lookup).with('lookup_options', any_parameters).at_most_once.throws(:no_such_key)
       Hiera.any_instance.expects(:lookup).with('abc::e', anything, anything, anything, { :behavior => :native }).returns({ 'k1' => 'global_e1' })
       resources = assemble_and_compile('${r[k1]}_${r[k2]}_${r[k3]}', "'abc::e'", 'Hash[String,String]', "{strategy => 'hash'}")
       expect(resources).to include('global_e1_module_e2_env_e3')
     end
 
     it 'will propagate a Hash resolution_type with :behavior => :deeper to Hiera when merge == \'deep\''  do
+      Hiera.any_instance.expects(:lookup).with('lookup_options', any_parameters).at_most_once.throws(:no_such_key)
       Hiera.any_instance.expects(:lookup).with('abc::f', anything, anything, anything, { :behavior => :deeper }).returns({ 'k1' => { 's1' => 'global_f11' }, 'k2' => { 's3' => 'global_f23' }})
       resources = assemble_and_compile('${r[k1][s1]}_${r[k1][s2]}_${r[k1][s3]}_${r[k2][s1]}_${r[k2][s2]}_${r[k2][s3]}', "'abc::f'", 'Hash[String,Hash[String,String]]', "'deep'")
       expect(resources).to include('global_f11_env_f12_module_f13_env_f21_module_f22_global_f23')
     end
 
     it 'will propagate a Hash resolution_type with symbolic deep merge options to Hiera'  do
+      Hiera.any_instance.expects(:lookup).with('lookup_options', any_parameters).at_most_once.throws(:no_such_key)
       Hiera.any_instance.expects(:lookup).with('abc::f', anything, anything, anything, { :behavior => :deeper, :knockout_prefix => '--' }).returns({ 'k1' => { 's1' => 'global_f11' }, 'k2' => { 's3' => 'global_f23' }})
       resources = assemble_and_compile('${r[k1][s1]}_${r[k1][s2]}_${r[k1][s3]}_${r[k2][s1]}_${r[k2][s2]}_${r[k2][s3]}', "'abc::f'", 'Hash[String,Hash[String,String]]', "{ 'strategy' => 'deep', 'knockout_prefix' => '--' }")
       expect(resources).to include('global_f11_env_f12_module_f13_env_f21_module_f22_global_f23')
@@ -226,7 +248,8 @@ describe "when performing lookup" do
       it 'fails unless default is an instance of value_type' do
         expect do
           assemble_and_compile('${r[a]}_${r[b]}', "'abc::x'", 'Hash[String,String]', 'undef', "{'a' => 'dflt_x', 'b' => 32}")
-        end.to raise_error(Puppet::ParseError, /default_value value has wrong type/)
+        end.to raise_error(Puppet::ParseError,
+          /Default value had wrong type, entry 'b' expected a String value, got Integer/)
       end
     end
 
@@ -259,7 +282,8 @@ describe "when performing lookup" do
       it 'fails unless block returns an instance of value_type' do
         expect do
           assemble_and_compile_with_block('${r[a]}_${r[b]}', "{'a' => 'dflt_x', 'b' => 32}", "'abc::x'", 'Hash[String,String]')
-        end.to raise_error(Puppet::ParseError, /default_block value has wrong type/)
+        end.to raise_error(Puppet::ParseError,
+          /Value returned from default block had wrong type, entry 'b' expected a String value, got Integer/)
       end
 
       it 'receives a single name parameter' do
@@ -274,6 +298,38 @@ describe "when performing lookup" do
     end
   end
 
+  context 'when using dotted keys' do
+    it 'can access values in data using dot notation' do
+      source = <<-CODE
+      function environment::data() {
+        { a => { b => { c => 'the data' }}}
+      }
+      notice(lookup('a.b.c'))
+      CODE
+      expect(eval_and_collect_notices(source)).to include('the data')
+    end
+
+    it 'can find data using quoted dot notation' do
+      source = <<-CODE
+      function environment::data() {
+        { 'a.b.c' => 'the data' }
+      }
+      notice(lookup('"a.b.c"'))
+      CODE
+      expect(eval_and_collect_notices(source)).to include('the data')
+    end
+
+    it 'can access values in data using a mix of dot notation and quoted dot notation' do
+      source = <<-CODE
+      function environment::data() {
+        { 'a' => { 'b.c' => 'the data' }}
+      }
+      notice(lookup('a."b.c"'))
+      CODE
+      expect(eval_and_collect_notices(source)).to include('the data')
+    end
+  end
+
   context 'when passing a hash as the only parameter' do
     it 'can pass a single name correctly' do
       resources = assemble_and_compile('${r}', "{name => 'abc::a'}")
@@ -323,42 +379,355 @@ describe "when performing lookup" do
   end
 
   context 'when accessing from outside a module' do
-    it 'will raise an exception when key in the function provided module data is not prefixed' do
-      Puppet[:code] = "include bad_data\nlookup(bad_data::b)"
-      expect do
-        compiler.compile()
-      end.to raise_error(Puppet::ParseError, /data for module 'bad_data' must use keys qualified with the name of the module/)
+    it 'will both log a warning and raise an exception when key in the function provided module data is not prefixed' do
+      logs = []
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        Puppet[:code] = "include bad_data\nlookup('bad_data::b')"
+        expect { compiler.compile }.to raise_error(Puppet::ParseError, /did not find a value for the name 'bad_data::b'/)
+      end
+      warnings = logs.select {|log| log.level == :warning }.map {|log| log.message }
+      expect(warnings).to include("Module data for module 'bad_data' must use keys qualified with the name of the module")
+    end
+
+    it 'will succeed finding prefixed keys even when a key in the function provided module data is not prefixed' do
+      logs = []
+      resources = nil
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        resources = compile_and_get_notifications(<<-END.gsub(/^ {10}/, ''))
+          include bad_data
+          notify { lookup('bad_data::c'): }
+        END
+        expect(resources).to include('module_c')
+      end
+      warnings = logs.select {|log| log.level == :warning }.map {|log| log.message }
+      expect(warnings).to include("Module data for module 'bad_data' must use keys qualified with the name of the module")
     end
 
     it 'will resolve global, environment, and module correctly' do
+      Hiera.any_instance.expects(:lookup).with('lookup_options', any_parameters).at_most_once.throws(:no_such_key)
       Hiera.any_instance.expects(:lookup).with('bca::e', any_parameters).returns({ 'k1' => 'global_e1' })
-      Puppet[:code] = <<-END.gsub(/^ {8}/, '')
+      resources = compile_and_get_notifications(<<-END.gsub(/^ {8}/, '')
         include bca
         $r = lookup(bca::e, Hash[String,String], hash)
         notify { "${r[k1]}_${r[k2]}_${r[k3]}": }
       END
-      resources = compiler.compile().resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
+      )
       expect(resources).to include('global_e1_module_bca_e2_env_bca_e3')
     end
 
     it 'will resolve global and environment correctly when module has no provider' do
+      Hiera.any_instance.expects(:lookup).with('lookup_options', any_parameters).at_most_once.throws(:no_such_key)
       Hiera.any_instance.expects(:lookup).with('no_provider::e', any_parameters).returns({ 'k1' => 'global_e1' })
-      Puppet[:code] = <<-END.gsub(/^ {8}/, '')
+      resources = compile_and_get_notifications(<<-END.gsub(/^ {8}/, '')
         include no_provider
         $r = lookup(no_provider::e, Hash[String,String], hash)
         notify { "${r[k1]}_${r[k2]}_${r[k3]}": }
       END
-      resources = compiler.compile().resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
+      )
       expect(resources).to include('global_e1__env_no_provider_e3') # k2 is missing
     end
   end
 
   context 'when accessing bad data' do
-    it 'will raise an exception when key in the function provided module data is not prefixed' do
-      Puppet[:code] = 'include bad_data'
-      expect do
-        compiler.compile()
-      end.to raise_error(Puppet::ParseError, /data for module 'bad_data' must use keys qualified with the name of the module/)
+    it 'a warning will be logged when key in the function provided module data is not prefixed' do
+      Puppet[:code] = "include bad_data\nlookup('bad_data::c')"
+      logs = []
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        compiler.compile
+      end
+      warnings = logs.select {|log| log.level == :warning }.map {|log| log.message }
+      expect(warnings).to include("Module data for module 'bad_data' must use keys qualified with the name of the module")
+    end
+
+    it 'a warning will be logged when key in the hiera provided module data is not prefixed' do
+      Puppet[:code] = "include hieraprovider\nlookup('hieraprovider::test::param_a')"
+      logs = []
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        compiler.compile
+      end
+      warnings = logs.select {|log| log.level == :warning }.map {|log| log.message }
+      expect(warnings).to include("Module data for module 'hieraprovider' must use keys qualified with the name of the module")
+    end
+  end
+
+  context 'when accessing empty files' do
+    # An empty YAML file is OK and should be treated as a file that contains no keys
+    it "will fail normally with a 'did not find a value' error when a yaml file is empty" do
+      Puppet[:code] = "include empty_yaml\nlookup('empty_yaml::a')"
+      expect { compiler.compile }.to raise_error(Puppet::ParseError, /did not find a value for the name 'empty_yaml::a'/)
+    end
+
+    # An empty JSON file is not OK. Should yield a parse error
+    it "will fail with a LookupError indicating a parser failure when a json file is empty" do
+      Puppet[:code] = "include empty_json\nlookup('empty_json::a')"
+      expect { compiler.compile }.to raise_error(Puppet::DataBinding::LookupError, /Unable to parse/)
+    end
+  end
+
+  context 'when accessing nil values' do
+    it 'will find a key with undef value in a yaml file' do
+      Puppet[:code] = 'include empty_key_yaml'
+      compiler.compile do |catalog|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('empty_key_yaml::has_undef_value',nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::Error
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "empty_key_yaml::has_undef_value"
+  Data Provider "FunctionEnvDataProvider"
+    No such key: "empty_key_yaml::has_undef_value"
+  Module "empty_key_yaml" using Data Provider "Hiera Data Provider, version 4"
+    ConfigurationPath "#{environmentpath}/production/modules/empty_key_yaml/hiera.yaml"
+    Data Provider "empty_key"
+      Path "#{environmentpath}/production/modules/empty_key_yaml/data/empty_key.yaml"
+        Original path: "empty_key"
+        Found key: "empty_key_yaml::has_undef_value" value: nil
+  Merged result: nil
+EOS
+      end
+    end
+
+    it 'will find a key with undef value in a json file' do
+      Puppet[:code] = 'include empty_key_json'
+      compiler.compile do |catalog|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('empty_key_json::has_undef_value',nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::Error
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "empty_key_json::has_undef_value"
+  Data Provider "FunctionEnvDataProvider"
+    No such key: "empty_key_json::has_undef_value"
+  Module "empty_key_json" using Data Provider "Hiera Data Provider, version 4"
+    ConfigurationPath "#{environmentpath}/production/modules/empty_key_json/hiera.yaml"
+    Data Provider "empty_key"
+      Path "#{environmentpath}/production/modules/empty_key_json/data/empty_key.json"
+        Original path: "empty_key"
+        Found key: "empty_key_json::has_undef_value" value: nil
+  Merged result: nil
+EOS
+      end
     end
   end
+
+  context 'when using explain' do
+    it 'will explain that module is not found' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('ppx::e',nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::Error
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "ppx::e"
+  Data Provider "FunctionEnvDataProvider"
+    No such key: "ppx::e"
+  Module "ppx"
+    Module not found
+EOS
+      end
+    end
+
+    it 'will explain that module does not find a key' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('abc::x', nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::Error
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "abc::x"
+  Data Provider "FunctionEnvDataProvider"
+    No such key: "abc::x"
+  Module "abc" using Data Provider "FunctionModuleDataProvider"
+    No such key: "abc::x"
+EOS
+      end
+    end
+
+    it 'will explain deep merge results without options' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        Puppet::Pops::Lookup.lookup('abc::e', Puppet::Pops::Types::TypeParser.new.parse('Hash[String,String]'), nil, false, 'deep', lookup_invocation)
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy deep
+  Data Binding "hiera"
+    No such key: "abc::e"
+  Data Provider "FunctionEnvDataProvider"
+    Found key: "abc::e" value: {
+      "k1" => "env_e1",
+      "k3" => "env_e3"
+    }
+  Module "abc" using Data Provider "FunctionModuleDataProvider"
+    Found key: "abc::e" value: {
+      "k1" => "module_e1",
+      "k2" => "module_e2"
+    }
+  Merged result: {
+    "k1" => "env_e1",
+    "k2" => "module_e2",
+    "k3" => "env_e3"
+  }
+EOS
+      end
+    end
+
+    it 'will explain deep merge results with options' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        Hiera.any_instance.expects(:lookup).with(any_parameters).returns({'k1' => 'global_g1'})
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        Puppet::Pops::Lookup.lookup('abc::e', Puppet::Pops::Types::TypeParser.new.parse('Hash[String,String]'), nil, false, {'strategy' => 'deep', 'merge_hash_arrays' => true}, lookup_invocation)
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy deep
+  Options: {
+    "merge_hash_arrays" => true
+  }
+  Data Binding "hiera"
+    Found key: "abc::e" value: {
+      "k1" => "global_g1"
+    }
+  Data Provider "FunctionEnvDataProvider"
+    Found key: "abc::e" value: {
+      "k1" => "env_e1",
+      "k3" => "env_e3"
+    }
+  Module "abc" using Data Provider "FunctionModuleDataProvider"
+    Found key: "abc::e" value: {
+      "k1" => "module_e1",
+      "k2" => "module_e2"
+    }
+  Merged result: {
+    "k1" => "global_g1",
+    "k2" => "module_e2",
+    "k3" => "env_e3"
+  }
+EOS
+      end
+    end
+
+    it 'will handle path merge when some entries are not found correctly' do
+      assemble_and_compile('${r}', "'hieraprovider::test::param_a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('hieraprovider::test::not_found', nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::DataBinding::LookupError
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "hieraprovider::test::not_found"
+  Data Provider "FunctionEnvDataProvider"
+    No such key: "hieraprovider::test::not_found"
+  Module "hieraprovider" using Data Provider "Hiera Data Provider, version 4"
+    ConfigurationPath "#{environmentpath}/production/modules/hieraprovider/hiera.yaml"
+    Data Provider "two paths"
+      Merge strategy first
+        Path "#{environmentpath}/production/modules/hieraprovider/data/first.json"
+          Original path: "first"
+          No such key: "hieraprovider::test::not_found"
+        Path "#{environmentpath}/production/modules/hieraprovider/data/second_not_present.json"
+          Original path: "second_not_present"
+          Path not found
+EOS
+      end
+    end
+
+    it 'will explain value access caused by dot notation in key' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        Puppet::Pops::Lookup.lookup('abc::f.k1.s1', Puppet::Pops::Types::TypeParser.new.parse('String'), nil, false, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "abc::f.k1.s1"
+  Data Provider "FunctionEnvDataProvider"
+    Sub key: "k1.s1"
+      Found key: "k1" value: {
+        "s1" => "env_f11",
+        "s2" => "env_f12"
+      }
+      Found key: "s1" value: "env_f11"
+    Found key: "abc::f.k1.s1" value: "env_f11"
+  Merged result: "env_f11"
+EOS
+      end
+    end
+
+
+    it 'will provide a hash containing all explanation elements' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        Puppet::Pops::Lookup.lookup('abc::e', Puppet::Pops::Types::TypeParser.new.parse('Hash[String,String]'), nil, false, {'strategy' => 'deep', 'merge_hash_arrays' => true}, lookup_invocation)
+        expect(lookup_invocation.explainer.to_hash).to eq(
+            {
+              :branches => [
+              {
+                :key => 'abc::e',
+                :event => :not_found,
+                :type => :global,
+                :name => :hiera
+              },
+              {
+                :key => 'abc::e',
+                :value => { 'k1' => 'env_e1', 'k3' => 'env_e3' },
+                :event => :found,
+                :type => :data_provider,
+                :name => 'FunctionEnvDataProvider'
+              },
+              {
+                :key => 'abc::e',
+                :value => { 'k1' => 'module_e1', 'k2' => 'module_e2' },
+                :event => :found,
+                :type => :data_provider,
+                :name => 'FunctionModuleDataProvider',
+                :module => 'abc'
+              }
+            ],
+              :value => { 'k1' => 'env_e1', 'k2' => 'module_e2', 'k3' => 'env_e3' },
+              :event => :result,
+              :merge => :deep,
+              :options => { 'merge_hash_arrays' => true },
+              :type => :merge
+            }
+          )
+      end
+    end
+
+    it 'will explain that "lookup_options" is an invalid key' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('lookup_options', nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::Error
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Invalid key "lookup_options"
+EOS
+      end
+    end
+
+    it 'will explain that "lookup_options" is an invalid key for any key starting with "lookup_options."' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('lookup_options.subkey', nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::Error
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Invalid key "lookup_options"
+EOS
+      end
+    end
+
+  end
 end