puppet 4.9.3-universal-darwin → 4.9.4-universal-darwin

data/lib/puppet/pops/lookup/invocation.rb

@@ -122,6 +122,20 @@ class Invocation
     end
   end
 
+  def without_explain
+    if explainer.nil?
+      yield
+    else
+      save_explainer = @explainer
+      begin
+        @explainer = nil
+        yield
+      ensure
+        @explainer = save_explainer
+      end
+    end
+  end
+
   def only_explain_options?
     @explainer.nil? ? false : @explainer.only_explain_options?
   end

data/lib/puppet/pops/lookup/lookup_key_function_provider.rb

@@ -91,8 +91,9 @@ class V3BackendFunctionProvider < LookupKeyFunctionProvider
     @backend ||= instantiate_backend(lookup_invocation)
     config = parent_data_provider.config(lookup_invocation)
 
-    # Never pass hiera.yaml defined merge_behavior down to the backend. It will pick it up from the config
-    resolution_type = lookup_invocation.hiera_v3_merge_behavior? ? nil : convert_merge(merge)
+    # A merge_behavior retrieved from hiera.yaml must not be converted here. Instead, passing the symbol :hash
+    # tells the V3 backend to pick it up from the config.
+    resolution_type = lookup_invocation.hiera_v3_merge_behavior? ? :hash : convert_merge(merge)
     @backend.lookup(key, lookup_invocation.scope, lookup_invocation.hiera_v3_location_overrides, resolution_type, context = {:recurse_guard => nil})
   end
 

data/lib/puppet/pops/types/types.rb

@@ -138,13 +138,22 @@ class PAnyType < TypedModelObject
     end
   end
 
-  # Returns `true` if this instance is a callable that accepts the given _args_
+  # Returns `true` if this instance is a callable that accepts the given _args_type_ type
   #
-  # @param args [PAnyType] the arguments to test
+  # @param args_type [PAnyType] the arguments to test
   # @param guard [RecursionGuard] guard against recursion. Only used by internal calls
   # @return [Boolean] `true` if this instance is a callable that accepts the given _args_
-  def callable?(args, guard = nil)
-    args.is_a?(PAnyType) && kind_of_callable? && args.callable_args?(self, guard)
+  def callable?(args_type, guard = nil)
+    args_type.is_a?(PAnyType) && kind_of_callable? && args_type.callable_args?(self, guard)
+  end
+
+  # Returns `true` if this instance is a callable that accepts the given _args_
+  #
+  # @param args [Array] the arguments to test
+  # @param block [Proc] block, or nil if not called with a block
+  # @return [Boolean] `true` if this instance is a callable that accepts the given _args_
+  def callable_with?(args,  block = nil)
+    false
   end
 
   # Returns `true` if this instance is considered valid as arguments to the given `callable`
@@ -438,8 +447,10 @@ class PType < PTypeWithContainedType
   def instance?(o, guard = nil)
     if o.is_a?(PAnyType)
       type.nil? || type.assignable?(o, guard)
+    elsif o.is_a?(Module) || o.is_a?(Puppet::Resource) || o.is_a?(Puppet::Parser::Resource)
+      @type.nil? ? true : assignable?(TypeCalculator.infer(o))
     else
-      assignable?(TypeCalculator.infer(o), guard)
+      false
     end
   end
 
@@ -671,7 +682,13 @@ class PScalarType < PAnyType
   end
 
   def instance?(o, guard = nil)
-    assignable?(TypeCalculator.infer(o), guard)
+    if o.is_a?(String) || o.is_a?(Numeric) || o.is_a?(TrueClass) || o.is_a?(FalseClass) || o.is_a?(Regexp) || o.is_a?(SemanticPuppet::VersionRange)
+      true
+    elsif o.is_a?(Array) || o.is_a?(Hash) || o.is_a?(PAnyType) || o.is_a?(NilClass)
+      false
+    else
+      assignable?(TypeCalculator.infer(o))
+    end
   end
 
   DEFAULT = PScalarType.new
@@ -732,6 +749,10 @@ class PEnumType < PScalarType
     self.class == o.class && @values == o.values
   end
 
+  def instance?(o, guard = nil)
+    o.is_a?(String) && @values.any? { |p| p == o }
+  end
+
   DEFAULT = PEnumType.new(EMPTY_ARRAY)
 
   protected
@@ -746,10 +767,9 @@ class PEnumType < PScalarType
     case o
       when PStringType
         # if the contained string is found in the set of enums
-        v = o.value
-        !v.nil? && svalues.any? { |e| e == v }
+        instance?(o.value, guard)
       when PEnumType
-        !o.values.empty? && o.values.all? { |s| svalues.any? {|e| e == s }}
+        !o.values.empty? && o.values.all? { |s| instance?(s, guard) }
       else
         false
     end
@@ -1195,7 +1215,11 @@ class PCollectionType < PAnyType
   end
 
   def instance?(o, guard = nil)
-    assignable?(TypeCalculator.infer(o), guard)
+    if o.is_a?(Array) || o.is_a?(Hash)
+      @size_type.nil? || @size_type.instance?(o.size)
+    else
+      false
+    end
   end
 
   # Returns an array with from (min) size to (max) size
@@ -1554,6 +1578,10 @@ class PRegexpType < PScalarType
     self.class == o.class && @pattern == o.pattern
   end
 
+  def instance?(o, guard=nil)
+    o.is_a?(Regexp) && (@pattern.nil? || @pattern == (o.options == 0 ? o.source : o.to_s))
+  end
+
   DEFAULT = PRegexpType.new(nil)
 
   protected
@@ -1594,6 +1622,10 @@ class PPatternType < PScalarType
     self.class == o.class && @patterns.size == o.patterns.size && (@patterns - o.patterns).empty?
   end
 
+  def instance?(o, guard = nil)
+    o.is_a?(String) && (@patterns.empty? || @patterns.any? { |p| p.regexp.match(o) })
+  end
+
   DEFAULT = PPatternType.new(EMPTY_ARRAY)
 
   protected
@@ -2007,14 +2039,15 @@ class PTupleType < PAnyType
 
   def instance?(o, guard = nil)
     return false unless o.is_a?(Array)
-    # compute the tuple's min/max size, and check if that size matches
-    size_t = size_type || PIntegerType.new(*size_range)
-
-    return false unless size_t.instance?(o.size, guard)
-    o.each_with_index do |element, index|
-      return false unless (types[index] || types[-1]).instance?(element, guard)
+    if @size_type
+      return false unless @size_type.instance?(o.size, guard)
+    else
+      return false unless @types.empty? || @types.size == o.size
+    end
+    index = -1
+    @types.empty? || o.all? do |element|
+      @types.fetch(index += 1) { @types.last }.instance?(element, guard)
     end
-    true
   end
 
   def iterable?(guard = nil)
@@ -2174,7 +2207,22 @@ class PCallableType < PAnyType
   end
 
   def instance?(o, guard = nil)
-    assignable?(TypeCalculator.infer(o), guard)
+    (o.is_a?(Proc) || o.is_a?(Evaluator::Closure) || o.is_a?(Functions::Function)) && assignable?(TypeCalculator.infer(o), guard)
+  end
+
+  # Returns `true` if this instance is a callable that accepts the given _args_
+  #
+  # @param args [Array] the arguments to test
+  # @return [Boolean] `true` if this instance is a callable that accepts the given _args_
+  def callable_with?(args, block = nil)
+    # nil param_types and compatible return type means other Callable is assignable
+    return true if @param_types.nil?
+    return false unless @param_types.instance?(args)
+    if @block_type.nil?
+      block == nil
+    else
+      @block_type.instance?(block)
+    end
   end
 
   # @api private
@@ -2710,10 +2758,9 @@ class PVariantType < PAnyType
   end
 
   def really_instance?(o, guard = nil)
-    @types.inject(-1) do |memo, type|
+    @types.reduce(-1) do |memo, type|
       ri = type.really_instance?(o, guard)
-      memo = ri if ri > memo
-      memo
+      ri > memo ? ri : memo
     end
   end
 

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '4.9.3'
+  PUPPETVERSION = '4.9.4'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/unit/functions/hiera_spec.rb

@@ -35,7 +35,13 @@ describe 'when calling' do
                 when 'datasources'
                   Hiera::Backend.datasources(scope, order_override) { |source| source }
                 when 'resolution_type'
-                  "resolution_type=\#{resolution_type}"
+                  if resolution_type == :hash
+                    { key => resolution_type.to_s }
+                  elsif resolution_type == :array
+                    [ key, resolution_type.to_s ]
+                  else
+                    "resolution_type=\#{resolution_type}"
+                  end
                 else
                   throw :no_such_key
                 end
@@ -349,7 +355,9 @@ describe 'when calling' do
     end
   end
 
-  context 'with merge_behavior declared in hiera.yaml' do
+  context 'with custom backend and merge_behavior declared in hiera.yaml' do
+    let(:merge_behavior) { 'deeper' }
+
     let(:hiera_yaml) do
       <<-YAML.unindent
         ---
@@ -359,9 +367,11 @@ describe 'when calling' do
         :yaml:
           :datadir: #{global_dir}/hieradata
         :hierarchy:
-          - other
           - common
-        :merge_behavior: deeper
+          - other
+        :merge_behavior: #{merge_behavior}
+        :deep_merge_options:
+          :unpack_arrays: ','
         YAML
     end
 
@@ -370,20 +380,37 @@ describe 'when calling' do
         'hiera.yaml' => hiera_yaml,
         'hieradata' => {
           'common.yaml' => <<-YAML.unindent,
+            da:
+              - da 0
+              - da 1
             dm:
               dm1:
                 dm11: value of dm11 (from common)
                 dm12: value of dm12 (from common)
               dm2:
                 dm21: value of dm21 (from common)
+            hash:
+              array:
+                - x1,x2
+            array:
+              - x1,x2
             YAML
           'other.yaml' => <<-YAML.unindent,
+            da:
+              - da 2,da 3
             dm:
               dm1:
                 dm11: value of dm11 (from other)
                 dm13: value of dm13 (from other)
               dm3:
                 dm31: value of dm31 (from other)
+            hash:
+              array:
+                - x3
+                - x4
+            array:
+              - x3
+              - x4
             YAML
         },
         'ruby_stuff' => ruby_stuff_files
@@ -393,23 +420,65 @@ describe 'when calling' do
     context 'hiera_hash' do
       let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera_hash') }
 
-      it 'the imposed hash strategy does not override declared merge_behavior' do
-        expect(func('dm')).to eql({
-          'dm1' => {
-            'dm11' => 'value of dm11 (from other)',
-            'dm12' => 'value of dm12 (from common)',
-            'dm13' => 'value of dm13 (from other)'
-          },
-          'dm2' => {
-            'dm21' => 'value of dm21 (from common)'
-          },
-          'dm3' => {
-            'dm31' => 'value of dm31 (from other)'
-          }
-        })
+      context "using 'deeper'" do
+        it 'declared merge_behavior is honored' do
+          expect(func('dm')).to eql({
+            'dm1' => {
+              'dm11' => 'value of dm11 (from common)',
+              'dm12' => 'value of dm12 (from common)',
+              'dm13' => 'value of dm13 (from other)'
+            },
+            'dm2' => {
+              'dm21' => 'value of dm21 (from common)'
+            },
+            'dm3' => {
+              'dm31' => 'value of dm31 (from other)'
+            }
+          })
+        end
+
+        it "merge behavior is propagated to a custom backend as 'hash'" do
+          expect(func('resolution_type')).to eql({ 'resolution_type' => 'hash' })
+        end
+
+        it 'fails on attempts to merge an array' do
+          expect {func('da')}.to raise_error(/expects a Hash value/)
+        end
+
+        it 'honors option :unpack_arrays: (unsupported by puppet)' do
+          expect(func('hash')).to eql({'array' => %w(x3 x4 x1 x2)})
+        end
+      end
+
+      context "using 'deep'" do
+        let(:merge_behavior) { 'deep' }
+
+        it 'honors option :unpack_arrays: (unsupported by puppet)' do
+          expect(func('hash')).to eql({'array' => %w(x1 x2 x3 x4)})
+        end
+      end
+    end
+
+    context 'hiera_array' do
+      let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera_array') }
+
+      it 'declared merge_behavior is ignored' do
+        expect(func('da')).to eql(['da 0', 'da 1', 'da 2,da 3'])
+      end
+
+      it "merge behavior is propagated to a custom backend as 'array'" do
+        expect(func('resolution_type')).to eql(['resolution_type', 'array'])
+      end
+    end
+
+    context 'hiera' do
+      let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera') }
+
+      it 'declared merge_behavior is ignored' do
+        expect(func('da')).to eql(['da 0', 'da 1'])
       end
 
-      it "the merge behavior is not propagated to a custom backend as 'resolution_type'" do
+      it "no merge behavior is propagated to a custom backend" do
         expect(func('resolution_type')).to eql('resolution_type=')
       end
     end

data/spec/unit/functions/lookup_spec.rb

@@ -73,7 +73,9 @@ describe "The lookup function" do
                   case key
                   when 'hash_c'
                     { 'hash_ca' => { 'cad' => 'value hash_c.hash_ca.cad (from global custom)' }}
-                  when 'h'
+                  when 'hash'
+                    { 'array' => [ 'x5,x6' ] }
+                  when 'array'
                     [ 'x5,x6' ]
                   when 'datasources'
                     Hiera::Backend.datasources(scope, order_override) { |source| source }
@@ -98,6 +100,7 @@ describe "The lookup function" do
     end
 
     let(:logs) { [] }
+    let(:scope_additions ) { {} }
     let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
     let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
     let(:debugs) { logs.select { |log| log.level == :debug }.map { |log| log.message } }
@@ -154,7 +157,7 @@ describe "The lookup function" do
         if Hiera.const_defined?(:Config)
           Hiera::Config.send(:remove_instance_variable, :@config) if Hiera::Config.instance_variable_defined?(:@config)
         end
-        if Hiera.const_defined?(:Backend)
+        if Hiera.const_defined?(:Backend) && Hiera::Backend.respond_to?(:clear!)
           Hiera::Backend.clear!
         end
       end
@@ -166,8 +169,7 @@ describe "The lookup function" do
         scope = compiler.topscope
         scope['environment'] = env_name
         scope['domain'] = 'example.com'
-        scope['scope_scalar'] = 'scope scalar value'
-        scope['scope_hash'] = { 'a' => 'scope hash a', 'b' => 'scope hash b' }
+        scope_additions.each_pair { |k, v| scope[k] = v }
         if explain
           begin
             invocation_with_explain.lookup('dummy', nil) do
@@ -301,7 +303,7 @@ describe "The lookup function" do
           hierarchy:
             - name: "Varying"
               data_hash: yaml_data
-              path: "x%{::var.sub}.yaml"
+              path: "x%{var.sub}.yaml"
           YAML
       end
 
@@ -329,14 +331,28 @@ describe "The lookup function" do
         Puppet[:log_level] = 'debug'
         collect_notices("notice('success')") do |scope|
           expect(lookup_func.call(scope, 'y')).to eql('value y from x')
+          scope['var'] = { 'sub' => '_d' }
+          expect(lookup_func.call(scope, 'y')).to eql('value y from x_d')
+          nested_scope = scope.compiler.newscope(scope)
+          nested_scope['var'] = { 'sub' => '_e' }
+          expect(lookup_func.call(nested_scope, 'y')).to eql('value y from x_e')
+        end
+        expect(notices).to eql(['success'])
+        expect(debugs.any? { |m| m =~ /Hiera configuration recreated due to change of scope variables used in interpolation expressions/ }).to be_truthy
+      end
+
+      it 'does not include the lookups performed during stability check in explain output' do
+        Puppet[:log_level] = 'debug'
+        collect_notices("notice('success')") do |scope|
           var = { 'sub' => '_d' }
           scope['var'] = var
           expect(lookup_func.call(scope, 'y')).to eql('value y from x_d')
-          var['sub'] = '_e'
-          expect(lookup_func.call(scope, 'y')).to eql('value y from x_e')
+
+          # Second call triggers the check
+          expect(lookup_func.call(scope, 'y')).to eql('value y from x_d')
         end
         expect(notices).to eql(['success'])
-        expect(debugs.any? { |m| m =~ /Hiera configuration recreated due to change of scope variables used in interpolation expressions/ }).to be_truthy
+        expect(debugs.any? { |m| m =~ /Sub key: "sub"/ }).to be_falsey
       end
     end
 
@@ -926,12 +942,12 @@ describe "The lookup function" do
           expect(explanation).to include('Found key: "a" value: "value a (from global)"')
         end
 
-        it 'uses the merge behavior specified in global hiera.yaml to merge only global backends' do
+        it 'ignores merge behavior specified in global hiera.yaml' do
           expect(lookup('hash_b')).to eql(
-            { 'hash_ba' => { 'bab' => 'value hash_b.hash_ba.bab (from global)', 'bac' => 'value hash_b.hash_ba.bac (from global json)' } })
+            { 'hash_ba' => { 'bab' => 'value hash_b.hash_ba.bab (from global)'} })
         end
 
-        it 'uses the merge from lookup options to merge all layers and override merge_behavior specified in global hiera.yaml' do
+        it 'uses the merge from lookup options to merge all layers' do
           expect(lookup('hash_c')).to eql(
             { 'hash_ca' => { 'cab' => 'value hash_c.hash_ca.cab (from global)' } })
         end
@@ -1109,8 +1125,7 @@ describe "The lookup function" do
           end
         end
 
-        context 'using deep_merge_options supported by deep_merge gem but not supported by Puppet' do
-
+        context 'using deep_merge_options' do
           let(:hiera_yaml) do
             <<-YAML.unindent
               ---
@@ -1119,8 +1134,8 @@ describe "The lookup function" do
               :yaml:
                 :datadir: #{code_dir}/hieradata
               :hierarchy:
-                - other
                 - common
+                - other
               :merge_behavior: deeper
               :deep_merge_options:
                 :unpack_arrays: ','
@@ -1132,7 +1147,10 @@ describe "The lookup function" do
               'hiera.yaml' => hiera_yaml,
               'hieradata' => {
                 'common.yaml' => <<-YAML.unindent,
-                  h:
+                  hash:
+                    array:
+                      - x1,x2
+                  array:
                     - x1,x2
                   str: a string
                   mixed:
@@ -1140,7 +1158,11 @@ describe "The lookup function" do
                     y: hy
                   YAML
                 'other.yaml' => <<-YAML.unindent,
-                  h:
+                  hash:
+                    array:
+                      - x3
+                      - x4
+                  array:
                     - x3
                     - x4
                   str: another string
@@ -1152,49 +1174,20 @@ describe "The lookup function" do
             }
           end
 
-          it 'honors option :unpack_arrays: (unsupported by puppet)' do
-            expect(lookup('h')).to eql(%w(x1 x2 x3 x4))
+          it 'ignores configured merge_behavior when looking up arrays' do
+            expect(lookup('array')).to eql(['x1,x2'])
           end
 
-          it 'will treat merge of strings as a unique (first found)' do
-            expect(lookup('str')).to eql('another string')
+          it 'ignores configured merge_behavior when merging arrays' do
+            expect(lookup('array', 'merge' => 'unique')).to eql(['x1,x2', 'x3', 'x4'])
           end
 
-          it 'will treat merge of array and hash as a unique (first found)' do
-            expect(lookup('mixed')).to eql(%w(h1 h2))
+          it 'ignores configured merge_behavior when looking up hashes' do
+            expect(lookup('hash')).to eql({'array' => ['x1,x2']})
           end
 
-          context 'together with a custom backend' do
-            let(:hiera_yaml) do
-              <<-YAML.unindent
-                ---
-                :backends:
-                  - custom
-                  - yaml
-                :yaml:
-                  :datadir: #{code_dir}/hieradata
-                :hierarchy:
-                  - other
-                  - common
-                :merge_behavior: #{merge_behavior}
-                :deep_merge_options:
-                  :unpack_arrays: ','
-                YAML
-            end
-
-            context "using 'deeper'" do
-              let(:merge_behavior) { 'deeper' }
-              it 'honors option :unpack_arrays: (unsupported by puppet)' do
-                expect(lookup('h')).to eql(%w(x1 x2 x3 x4 x5 x6))
-              end
-            end
-
-            context "using 'deep'" do
-              let(:merge_behavior) { 'deep' }
-              it 'honors option :unpack_arrays: (unsupported by puppet)' do
-                expect(lookup('h')).to eql(%w(x5 x6 x3 x4 x1 x2))
-              end
-            end
+          it 'ignores configured merge_behavior when merging hashes' do
+            expect(lookup('hash', 'merge' => 'hash')).to eql({'array' => ['x1,x2']})
           end
         end
 
@@ -1241,12 +1234,13 @@ describe "The lookup function" do
       end
 
       context 'version 5' do
+        let(:scope_additions) { { 'ipl_datadir' => 'hieradata' } }
         let(:hiera_yaml) do
           <<-YAML.unindent
           ---
           version: 5
           defaults:
-            datadir: hieradata
+            datadir: "%{ipl_datadir}"
 
           hierarchy:
             - name: Yaml
@@ -1444,6 +1438,13 @@ describe "The lookup function" do
       end
 
       context 'using a data_hash that reads a yaml file' do
+        let(:scope_additions) do
+          {
+            'scope_scalar' => 'scope scalar value',
+            'scope_hash' => { 'a' => 'scope hash a', 'b' => 'scope hash b' }
+          }
+        end
+
         let(:mod_a_files) do
           {
             'mod_a' => {
@@ -1963,6 +1964,7 @@ describe "The lookup function" do
           YAML
       end
 
+      let(:scope_additions) { { 'ipl_suffix' => 'aa' } }
       let(:data_files) do
         {
           'common.eyaml' => <<-YAML.unindent
@@ -1978,7 +1980,7 @@ describe "The lookup function" do
               JHUngDDS5s52FsuSIMin7Z/pV+XuaJGFkL80ia4bXnCWilmtM8oUa/DZuBje
               dCILO7I8QqU=]
             hash_a:
-              hash_aa:
+              "hash_%{ipl_suffix}":
                 aaa: >
                   ENC[PKCS7,MIIBqQYJKoZIhvcNAQcDoIIBmjCCAZYCAQAxggEhMIIBHQIBADAFMAACAQEw
                   DQYJKoZIhvcNAQEBBQAEggEAhvGXL5RxVUs9wdqJvpCyXtfCHrm2HbG/u30L
@@ -2021,6 +2023,10 @@ describe "The lookup function" do
         expect(lookup('a')).to eql("Encrypted value 'a' (from environment)")
       end
 
+      it 'evaluates interpolated keys' do
+        expect(lookup('hash_a')).to include('hash_aa')
+      end
+
       it 'can read encrypted values inside a hash' do
         expect(lookup('hash_a.hash_aa.aaa')).to eql('Encrypted value hash_a.hash_aa.aaa (from environment)')
       end
@@ -2031,6 +2037,20 @@ describe "The lookup function" do
 
       context 'declared in global scope as a Hiera v3 backend' do
         let(:environment_files) { {} }
+        let(:data_file_content) { <<-YAML.unindent }
+          a: >
+            ENC[PKCS7,MIIBmQYJKoZIhvcNAQcDoIIBijCCAYYCAQAxggEhMIIBHQIBADAFMAACAQEw
+            DQYJKoZIhvcNAQEBBQAEggEAH457bsfL8kYw9O50roE3dcE21nCnmPnQ2XSX
+            LYRJ2C78LarbfFonKz0gvDW7tyhsLWASFCFaiU8T1QPBd2b3hoQK8E4B2Ual
+            xga/K7r9y3OSgRomTm9tpTltC6re0Ubh3Dy71H61obwxEdNVTqjPe95+m2b8
+            6zWZVnzZzXXsTG1S17yJn1zaB/LXHbWNy4KyLLKCGAml+Gfl6ZMjmaplTmUA
+            QIC5rI8abzbPP3TDMmbLOGNkrmLqI+3uS8tSueTMoJmWaMF6c+H/cA7oRxmV
+            QCeEUVXjyFvCHcmbA+keS/RK9XF+vc07/XS4XkYSPs/I5hLQji1y9bkkGAs0
+            tehxQjBcBgkqhkiG9w0BBwEwHQYJYIZIAWUDBAEqBBDHpA6Fcl/R16aIYcow
+            oiO4gDAvfFH6jLUwXkcYtagnwdmhkd9TQJtxNWcIwMpvmk036MqIoGwwhQdg
+            gV4beiCFtLU=]
+          YAML
+
         let(:hiera_yaml) do
           <<-YAML.unindent
           :backends: eyaml
@@ -2045,19 +2065,7 @@ describe "The lookup function" do
 
         let(:data_files) do
           {
-            'common.eyaml' => <<-YAML.unindent
-              a: >
-                ENC[PKCS7,MIIBmQYJKoZIhvcNAQcDoIIBijCCAYYCAQAxggEhMIIBHQIBADAFMAACAQEw
-                DQYJKoZIhvcNAQEBBQAEggEAH457bsfL8kYw9O50roE3dcE21nCnmPnQ2XSX
-                LYRJ2C78LarbfFonKz0gvDW7tyhsLWASFCFaiU8T1QPBd2b3hoQK8E4B2Ual
-                xga/K7r9y3OSgRomTm9tpTltC6re0Ubh3Dy71H61obwxEdNVTqjPe95+m2b8
-                6zWZVnzZzXXsTG1S17yJn1zaB/LXHbWNy4KyLLKCGAml+Gfl6ZMjmaplTmUA
-                QIC5rI8abzbPP3TDMmbLOGNkrmLqI+3uS8tSueTMoJmWaMF6c+H/cA7oRxmV
-                QCeEUVXjyFvCHcmbA+keS/RK9XF+vc07/XS4XkYSPs/I5hLQji1y9bkkGAs0
-                tehxQjBcBgkqhkiG9w0BBwEwHQYJYIZIAWUDBAEqBBDHpA6Fcl/R16aIYcow
-                oiO4gDAvfFH6jLUwXkcYtagnwdmhkd9TQJtxNWcIwMpvmk036MqIoGwwhQdg
-                gV4beiCFtLU=]
-              YAML
+            'common.eyaml' => data_file_content
           }
         end
 
@@ -2079,6 +2087,56 @@ describe "The lookup function" do
         it 'delegates configured eyaml backend to eyaml_lookup_key function' do
           expect(explain('a')).to match(/Hierarchy entry "eyaml"\n.*\n.*\n.*"common"\n\s*Found key: "a"/m)
         end
+
+        context 'using intepolated paths to the key pair' do
+          let(:scope_additions) { { 'priv_path' => private_key_path, 'pub_path' => public_key_path } }
+
+          let(:hiera_yaml) do
+            <<-YAML.unindent
+          :backends: eyaml
+          :eyaml:
+            :datadir: #{code_dir}/hieradata
+            :pkcs7_private_key: "%{priv_path}"
+            :pkcs7_public_key: "%{pub_path}"
+          :hierarchy:
+            - common
+            YAML
+          end
+
+          it 'finds data in the global layer' do
+            expect(lookup('a')).to eql("Encrypted value 'a' (from global)")
+          end
+        end
+
+        context 'with special extension declared in options' do
+          let(:environment_files) { {} }
+          let(:hiera_yaml) do
+            <<-YAML.unindent
+            :backends: eyaml
+            :eyaml:
+              :extension: xyaml
+              :datadir: #{code_dir}/hieradata
+              :pkcs7_private_key: #{private_key_path}
+              :pkcs7_public_key: #{public_key_path}
+            :hierarchy:
+              - common
+            YAML
+          end
+
+          let(:data_files) do
+            {
+              'common.xyaml' => data_file_content
+            }
+          end
+
+          it 'finds data in the global layer' do
+            expect(lookup('a')).to eql("Encrypted value 'a' (from global)")
+          end
+
+          it 'delegates configured eyaml backend to eyaml_lookup_key function' do
+            expect(explain('a')).to match(/Hierarchy entry "eyaml"\n.*\n.*\n.*"common"\n\s*Found key: "a"/m)
+          end
+        end
       end
     end
   end