puppet 4.3.0 → 4.4.0

data/spec/unit/configurer_spec.rb

@@ -369,12 +369,34 @@ describe Puppet::Configurer do
       expect(report.environment).to eq("second_env")
     end
 
-    it "should clear the global caches" do
-      $env_module_directories = false
+    it "sends the transaction uuid in a catalog request" do
+      @agent.instance_variable_set(:@transaction_uuid, 'aaa')
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => 'aaa'))
+      @agent.run
+    end
+
+    it "sets the static_catalog query param to true in a catalog request" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:static_catalog => true))
+      @agent.run
+    end
 
+    it "sets the checksum_type query param to the default supported_checksum_types in a catalog request" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything,
+        has_entries(:checksum_type => 'md5.sha256'))
       @agent.run
+    end
+
+    it "sets the checksum_type query param to the supported_checksum_types setting in a catalog request" do
+      # Regenerate the agent to pick up the new setting
+      Puppet[:supported_checksum_types] = ['sha256']
+      @agent = Puppet::Configurer.new
+      @agent.stubs(:init_storage)
+      @agent.stubs(:download_plugins)
+      @agent.stubs(:send_report)
+      @agent.stubs(:save_last_run_summary)
 
-      expect($env_module_directories).to eq(nil)
+      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:checksum_type => 'sha256'))
+      @agent.run
     end
 
     describe "when not using a REST terminus for catalogs" do
@@ -544,17 +566,42 @@ describe Puppet::Configurer do
     end
   end
 
+  def expects_new_catalog_only(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
+  end
+
+  def expects_cached_catalog_only(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
+  end
+
+  def expects_fallback_to_cached_catalog(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns catalog
+  end
+
+  def expects_fallback_to_new_catalog(catalog)
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns catalog
+  end
+
+  def expects_neither_new_or_cached_catalog
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
+  end
+
   describe "when retrieving a catalog" do
     before do
       Puppet.settings.stubs(:use).returns(true)
       @agent.stubs(:facts_for_uploading).returns({})
+      @agent.stubs(:download_plugins)
 
-      @catalog = Puppet::Resource::Catalog.new
+      # retrieve a catalog in the current environment, so we don't try to converge unexpectedly
+      @catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
 
       # this is the default when using a Configurer instance
       Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
-
-      @agent.stubs(:convert_catalog).returns @catalog
     end
 
     describe "and configured to only retrieve a catalog from the cache" do
@@ -563,18 +610,123 @@ describe Puppet::Configurer do
       end
 
       it "should first look in the cache for a catalog" do
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
+        expects_cached_catalog_only(@catalog)
 
         expect(@agent.retrieve_catalog({})).to eq(@catalog)
       end
 
+      it "should not make a node request or pluginsync when a cached catalog is successfully retrieved" do
+        Puppet::Node.indirection.expects(:find).never
+        expects_cached_catalog_only(@catalog)
+        @agent.expects(:download_plugins).never
+
+        @agent.run
+      end
+
+      it "should make a node request and pluginsync when a cached catalog cannot be retrieved" do
+        Puppet::Node.indirection.expects(:find).returns nil
+        expects_fallback_to_new_catalog(@catalog)
+        @agent.expects(:download_plugins)
+
+        @agent.run
+      end
+
+      it "should set its cached_catalog_status to 'explicitly_requested'" do
+        expects_cached_catalog_only(@catalog)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('explicitly_requested')
+      end
+
+      it "should set its cached_catalog_status to 'explicitly requested' if the cached catalog is from a different environment" do
+        cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+        expects_cached_catalog_only(cached_catalog)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('explicitly_requested')
+      end
+
       it "should compile a new catalog if none is found in the cache" do
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+        expects_fallback_to_new_catalog(@catalog)
 
         expect(@agent.retrieve_catalog({})).to eq(@catalog)
       end
+
+      it "should set its cached_catalog_status to 'not_used' if no catalog is found in the cache" do
+        expects_fallback_to_new_catalog(@catalog)
+
+        @agent.retrieve_catalog({})
+        expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+      end
+
+      it "should not attempt to retrieve a cached catalog again if the first attempt failed" do
+        Puppet::Node.indirection.expects(:find).returns(nil)
+        expects_neither_new_or_cached_catalog
+
+        @agent.run
+      end
+
+      it "should return the cached catalog when the environment doesn't match" do
+        cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+        expects_cached_catalog_only(cached_catalog)
+
+        Puppet.expects(:info).with("Using cached catalog from environment 'second_env'")
+        expect(@agent.retrieve_catalog({})).to eq(cached_catalog)
+      end
+    end
+
+    describe "and strict environment mode is set" do
+      before do
+        @catalog.stubs(:to_ral).returns(@catalog)
+        @catalog.stubs(:write_class_file)
+        @catalog.stubs(:write_resource_file)
+        @agent.stubs(:send_report)
+        @agent.stubs(:save_last_run_summary)
+        Puppet.settings[:strict_environment_mode] = true
+      end
+
+      it "should not make a node request" do
+        Puppet::Node.indirection.expects(:find).never
+
+        @agent.run
+      end
+
+      it "should return nil when the catalog's environment doesn't match the agent specified environment" do
+        @agent.instance_variable_set(:@environment, 'second_env')
+        expects_new_catalog_only(@catalog)
+
+        Puppet.expects(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
+        expect(@agent.run).to be_nil
+      end
+
+      it "should not return nil when the catalog's environment matches the agent specified environment" do
+        @agent.instance_variable_set(:@environment, 'production')
+        expects_new_catalog_only(@catalog)
+
+        expect(@agent.run).to eq(0)
+      end
+
+      describe "and a cached catalog is explicitly requested" do
+        before do
+          Puppet.settings[:use_cached_catalog] = true
+        end
+
+        it "should return nil when the cached catalog's environment doesn't match the agent specified environment" do
+          @agent.instance_variable_set(:@environment, 'second_env')
+          expects_cached_catalog_only(@catalog)
+
+          Puppet.expects(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
+          expect(@agent.run).to be_nil
+        end
+
+        it "should proceed with the cached catalog if its environment matchs the local environment" do
+          Puppet.settings[:use_cached_catalog] = true
+          @agent.instance_variable_set(:@environment, 'production')
+          expects_cached_catalog_only(@catalog)
+
+          expect(@agent.run).to eq(0)
+        end
+      end
     end
 
     it "should use the Catalog class to get its catalog" do
@@ -583,6 +735,13 @@ describe Puppet::Configurer do
       @agent.retrieve_catalog({})
     end
 
+    it "should set its cached_catalog_status to 'not_used' when downloading a new catalog" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+    end
+
     it "should use its node_name_value to retrieve the catalog" do
       Facter.stubs(:value).returns "eh"
       Puppet.settings[:node_name_value] = "myhost.domain.com"
@@ -598,17 +757,21 @@ describe Puppet::Configurer do
     end
 
     it "should log and return the cached catalog when no catalog can be retrieved from the server" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
-
-      Puppet.expects(:notice)
+      expects_fallback_to_cached_catalog(@catalog)
 
+      Puppet.expects(:info).with("Using cached catalog from environment 'production'")
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
+    it "should set its cached_catalog_status to 'on_failure' when no catalog can be retrieved from the server" do
+      expects_fallback_to_cached_catalog(@catalog)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+    end
+
     it "should not look in the cache for a catalog if one is returned from the server" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
+      expects_new_catalog_only(@catalog)
 
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
@@ -620,72 +783,141 @@ describe Puppet::Configurer do
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
+    it "should set its cached_catalog_status to 'on_failure' when retrieving the remote catalog throws an exception" do
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
+      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+    end
+
     it "should log and return nil if no catalog can be retrieved from the server and :usecacheonfailure is disabled" do
       Puppet[:usecacheonfailure] = false
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
 
-      Puppet.expects(:warning)
+      Puppet.expects(:warning).with('Not using cache on failed catalog')
 
       expect(@agent.retrieve_catalog({})).to be_nil
     end
 
-    it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
+    it "should set its cached_catalog_status to 'not_used' if no catalog can be retrieved from the server and :usecacheonfailure is disabled or fails to retrieve a catalog" do
+      Puppet[:usecacheonfailure] = false
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
 
-      expect(@agent.retrieve_catalog({})).to be_nil
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
     end
 
-    it "should convert the catalog before returning" do
-      Puppet::Resource::Catalog.indirection.stubs(:find).returns @catalog
+    it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
+      expects_neither_new_or_cached_catalog
 
-      @agent.expects(:convert_catalog).with { |cat, dur| cat == @catalog }.returns "converted catalog"
-      expect(@agent.retrieve_catalog({})).to eq("converted catalog")
+      expect(@agent.retrieve_catalog({})).to be_nil
     end
 
-    it "should return nil if there is an error while retrieving the catalog" do
-      Puppet::Resource::Catalog.indirection.expects(:find).at_least_once.raises "eh"
+    it "should return nil if its cached catalog environment doesn't match server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+      @agent.instance_variable_set(:@node_environment, 'production')
+
+      expects_fallback_to_cached_catalog(cached_catalog)
 
+      Puppet.expects(:err).with("Not using cached catalog because its environment 'second_env' does not match 'production'")
       expect(@agent.retrieve_catalog({})).to be_nil
     end
+
+    it "should set its cached_catalog_status to 'not_used' if the cached catalog environment doesn't match server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+      @agent.instance_variable_set(:@node_environment, 'production')
+
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
+    end
+
+    it "should return its cached catalog if the environment matches the server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment]))
+      @agent.instance_variable_set(:@node_environment, cached_catalog.environment)
+
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      expect(@agent.retrieve_catalog({})).to eq(cached_catalog)
+    end
+
+    it "should set its cached_catalog_status to 'on_failure' if the cached catalog environment matches server-specified environment" do
+      cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment]))
+      @agent.instance_variable_set(:@node_environment, cached_catalog.environment)
+
+      expects_fallback_to_cached_catalog(cached_catalog)
+
+      @agent.retrieve_catalog({})
+      expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
+    end
   end
 
   describe "when converting the catalog" do
     before do
       Puppet.settings.stubs(:use).returns(true)
 
-      @catalog = Puppet::Resource::Catalog.new
-      @oldcatalog = stub 'old_catalog', :to_ral => @catalog
+      catalog.stubs(:to_ral).returns ral_catalog
     end
 
-    it "should convert the catalog to a RAL-formed catalog" do
-      @oldcatalog.expects(:to_ral).returns @catalog
+    let (:catalog) { Puppet::Resource::Catalog.new('tester', Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
+    let (:ral_catalog) { Puppet::Resource::Catalog.new('tester', Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
 
-      expect(@agent.convert_catalog(@oldcatalog, 10)).to equal(@catalog)
+    it "should convert the catalog to a RAL-formed catalog" do
+      expect(@agent.convert_catalog(catalog, 10)).to equal(ral_catalog)
     end
 
     it "should finalize the catalog" do
-      @catalog.expects(:finalize)
+      ral_catalog.expects(:finalize)
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      @agent.convert_catalog(catalog, 10)
     end
 
     it "should record the passed retrieval time with the RAL catalog" do
-      @catalog.expects(:retrieval_duration=).with 10
+      ral_catalog.expects(:retrieval_duration=).with 10
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      @agent.convert_catalog(catalog, 10)
     end
 
     it "should write the RAL catalog's class file" do
-      @catalog.expects(:write_class_file)
+      ral_catalog.expects(:write_class_file)
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      @agent.convert_catalog(catalog, 10)
     end
 
     it "should write the RAL catalog's resource file" do
-      @catalog.expects(:write_resource_file)
+      ral_catalog.expects(:write_resource_file)
+
+      @agent.convert_catalog(catalog, 10)
+    end
+  end
+
+  describe "when determining whether to pluginsync" do
+    it "should default to Puppet[:pluginsync] when explicitly set by the commandline" do
+      Puppet.settings[:pluginsync] = false
+      Puppet.settings.expects(:set_by_cli?).returns(true)
+
+      expect(described_class).not_to be_should_pluginsync
+    end
+
+    it "should default to Puppet[:pluginsync] when explicitly set by config" do
+      Puppet.settings[:pluginsync] = false
+      Puppet.settings.expects(:set_by_config?).returns(true)
+
+      expect(described_class).not_to be_should_pluginsync
+    end
+
+    it "should be true if use_cached_catalog is false" do
+      Puppet.settings[:use_cached_catalog] = false
+
+      expect(described_class).to be_should_pluginsync
+    end
+
+    it "should be false if use_cached_catalog is true" do
+      Puppet.settings[:use_cached_catalog] = true
 
-      @agent.convert_catalog(@oldcatalog, 10)
+      expect(described_class).not_to be_should_pluginsync
     end
   end
 end

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -53,6 +53,12 @@ describe "when using a hiera data provider" do
     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 'keeps lookup_options in one module separate from lookup_options in another' do
+    resources1 = compile('hiera_modules', 'include one').resources.select {|r| r.ref.start_with?('Class[One]')}
+    resources2 = compile('hiera_modules', 'include two').resources.select {|r| r.ref.start_with?('Class[One]')}
+    expect(resources1).to eq(resources2)
+  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, ')
@@ -81,10 +87,8 @@ describe "when using a hiera data provider" do
     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')
+  it "will not find 'lookup_options' as a regular value" do
+    expect { compile_and_get_notifications('hiera_misc', '$r = lookup("lookup_options")') }.to raise_error(Puppet::DataBinding::LookupError, /did not find a value/)
   end
 
   it 'does find unqualified keys in the environment' do
@@ -180,16 +184,189 @@ Merge strategy first
     ConfigurationPath "#{environmentpath}/hiera_misc/hiera.yaml"
     Data Provider "common"
       Path "#{environmentpath}/hiera_misc/data/common.yaml"
-        Original path: common
+        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
+
+    it 'will report that merge options was found in the lookup_options hash' 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('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Using merge options from "lookup_options" hash
+Merge strategy deep
+  Data Binding "hiera"
+    No such key: "one::loptsm_test::hash"
+  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"
+        Found key: "one::loptsm_test::hash" value: {
+          "a" => "A",
+          "b" => "B",
+          "m" => {
+            "ma" => "MA",
+            "mb" => "MB"
+          }
+        }
+  Module "one" using Data Provider "Hiera Data Provider, version 4"
+    ConfigurationPath "#{environmentpath}/hiera_misc/modules/one/hiera.yaml"
+    Data Provider "common"
+      Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
+        Original path: "common"
+        Found key: "one::loptsm_test::hash" value: {
+          "a" => "A",
+          "c" => "C",
+          "m" => {
+            "ma" => "MA",
+            "mc" => "MC",
+            "mb" => "MB"
+          }
+        }
+  Merged result: {
+    "a" => "A",
+    "c" => "C",
+    "m" => {
+      "ma" => "MA",
+      "mc" => "MC",
+      "mb" => "MB"
+    },
+    "b" => "B"
+  }
+EOS
+      end
+    end
+
+    it 'will report lookup_options details in combination with details of found value' do
+      compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, Puppet::Pops::Lookup::Explainer.new(true))
+        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Searching for "lookup_options"
+  Merge strategy hash
+    Data Binding "hiera"
+      No such key: "lookup_options"
+    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"
+          Found key: "lookup_options" value: {
+            "one::lopts_test::hash" => {
+              "merge" => "deep"
+            }
+          }
+    Module "one" using Data Provider "Hiera Data Provider, version 4"
+      ConfigurationPath "#{environmentpath}/hiera_misc/modules/one/hiera.yaml"
+      Data Provider "common"
+        Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
+          Original path: "common"
+          Found key: "lookup_options" value: {
+            "one::loptsm_test::hash" => {
+              "merge" => "deep"
+            }
+          }
+    Merged result: {
+      "one::loptsm_test::hash" => {
+        "merge" => "deep"
+      },
+      "one::lopts_test::hash" => {
+        "merge" => "deep"
+      }
+    }
+Searching for "one::loptsm_test::hash"
+  Merge strategy deep
+    Data Binding "hiera"
+      No such key: "one::loptsm_test::hash"
+    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"
+          Found key: "one::loptsm_test::hash" value: {
+            "a" => "A",
+            "b" => "B",
+            "m" => {
+              "ma" => "MA",
+              "mb" => "MB"
+            }
+          }
+    Module "one" using Data Provider "Hiera Data Provider, version 4"
+      ConfigurationPath "#{environmentpath}/hiera_misc/modules/one/hiera.yaml"
+      Data Provider "common"
+        Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
+          Original path: "common"
+          Found key: "one::loptsm_test::hash" value: {
+            "a" => "A",
+            "c" => "C",
+            "m" => {
+              "ma" => "MA",
+              "mc" => "MC",
+              "mb" => "MB"
+            }
+          }
+    Merged result: {
+      "a" => "A",
+      "c" => "C",
+      "m" => {
+        "ma" => "MA",
+        "mc" => "MC",
+        "mb" => "MB"
+      },
+      "b" => "B"
+    }
+EOS
+      end
+    end
+
+    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, {}, {}, Puppet::Pops::Lookup::Explainer.new(true, true))
+        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy hash
+  Data Binding "hiera"
+    No such key: "lookup_options"
+  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"
+        Found key: "lookup_options" value: {
+          "one::lopts_test::hash" => {
+            "merge" => "deep"
+          }
+        }
+  Module "one" using Data Provider "Hiera Data Provider, version 4"
+    ConfigurationPath "#{environmentpath}/hiera_misc/modules/one/hiera.yaml"
+    Data Provider "common"
+      Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
+        Original path: "common"
+        Found key: "lookup_options" value: {
+          "one::loptsm_test::hash" => {
+            "merge" => "deep"
+          }
+        }
+  Merged result: {
+    "one::loptsm_test::hash" => {
+      "merge" => "deep"
+    },
+    "one::lopts_test::hash" => {
+      "merge" => "deep"
+    }
+  }
 EOS
       end
     end
   end
+
   def parent_fixture(dir_name)
     File.absolute_path(File.join(my_fixture_dir(), "../#{dir_name}"))
   end