puppet 4.9.1-universal-darwin → 4.9.2-universal-darwin

data/spec/unit/functions/lookup_spec.rb

@@ -13,6 +13,7 @@ describe "The lookup function" do
     let(:env_name) { 'spec' }
     let(:code_dir_files) { {} }
     let(:code_dir) { tmpdir('code') }
+    let(:ruby_dir) { tmpdir('ruby') }
     let(:environment_files) do
       {
         env_name => {
@@ -28,7 +29,9 @@ describe "The lookup function" do
         'data' => {
           'common.yaml' => <<-YAML.unindent
             ---
-            a: value a
+            a: value a (from environment)
+            c:
+              c_b: value c_b (from environment)
             mod_a::a: value mod_a::a (from environment)
             mod_a::hash_a:
               a: value mod_a::hash_a.a (from environment)
@@ -51,6 +54,40 @@ describe "The lookup function" do
       }
     end
 
+    let(:ruby_dir_files) do
+      {
+        'hiera' => {
+          'backend' => {
+            'custom_backend.rb' => <<-RUBY.unindent,
+              class Hiera::Backend::Custom_backend
+                def lookup(key, scope, order_override, resolution_type, context)
+                  case key
+                  when 'hash_c'
+                    { 'hash_ca' => { 'cad' => 'value hash_c.hash_ca.cad (from global custom)' }}
+                  when 'h'
+                    [ 'x5,x6' ]
+                  when 'datasources'
+                    Hiera::Backend.datasources(scope, order_override) { |source| source }
+                  else
+                    throw :no_such_key
+                  end
+                end
+              end
+              RUBY
+            'other_backend.rb' => <<-RUBY.unindent,
+              class Hiera::Backend::Other_backend
+                def lookup(key, scope, order_override, resolution_type, context)
+                  value = Hiera::Config[:other][key.to_sym]
+                  throw :no_such_key if value.nil?
+                  value
+                end
+              end
+              RUBY
+          }
+        }
+      }
+    end
+
     let(:logs) { [] }
     let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
     let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
@@ -79,6 +116,11 @@ describe "The lookup function" do
       code_dir
     end
 
+    let(:populated_ruby_dir) do
+      dir_contained_in(ruby_dir, ruby_dir_files)
+      ruby_dir
+    end
+
     let(:env_dir) do
       d = File.join(populated_code_dir, 'environments')
       Dir.mkdir(d)
@@ -158,7 +200,7 @@ describe "The lookup function" do
     end
 
     it 'finds data in the environment' do
-      expect(lookup('a')).to eql('value a')
+      expect(lookup('a')).to eql('value a (from environment)')
     end
 
     context 'that has no lookup configured' do
@@ -251,16 +293,19 @@ describe "The lookup function" do
               hierarchy:
                 - name: "Varying"
                   data_hash: yaml_data
-                  path: "x%{::var}.yaml"
+                  path: "x%{::var.sub}.yaml"
               YAML
             'modules' => {},
             'data' => {
               'x.yaml' => <<-YAML.unindent,
                 y: value y from x
               YAML
-              'x_d.yaml' => <<-YAML.unindent
+              'x_d.yaml' => <<-YAML.unindent,
                 y: value y from x_d
               YAML
+              'x_e.yaml' => <<-YAML.unindent
+                y: value y from x_e
+              YAML
             }
           }
         }
@@ -270,8 +315,11 @@ 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'] = '_d'
+          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')
         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
@@ -319,6 +367,119 @@ describe "The lookup function" do
       end
     end
 
+    context 'with yaml data file' do
+      let(:environment_files) do
+        {
+          env_name => {
+            'hiera.yaml' => <<-YAML.unindent,
+              ---
+              version: 5
+              YAML
+            'data' => {
+              'common.yaml' => common_yaml
+            }
+          }
+        }
+      end
+
+      context 'that contains hash values with interpolated keys' do
+        let(:common_yaml) do
+          <<-YAML.unindent
+          ---
+          a:
+              "%{key}": "the %{value}"
+          b:  "Detail in %{lookup('a.a_key')}"
+          YAML
+        end
+
+        it 'interpolates both key and value"' do
+          Puppet[:log_level] = 'debug'
+          collect_notices("notice('success')") do |scope|
+            expect(lookup_func.call(scope, 'a')).to eql({'' => 'the '})
+            scope['key'] = 'a_key'
+            scope['value'] = 'interpolated value'
+            expect(lookup_func.call(scope, 'a')).to eql({'a_key' => 'the interpolated value'})
+          end
+          expect(notices).to eql(['success'])
+        end
+
+        it 'navigates to a value behind an interpolated key"' do
+          Puppet[:log_level] = 'debug'
+          collect_notices("notice('success')") do |scope|
+            scope['key'] = 'a_key'
+            scope['value'] = 'interpolated value'
+            expect(lookup_func.call(scope, 'a.a_key')).to eql('the interpolated value')
+          end
+          expect(notices).to eql(['success'])
+        end
+
+        it 'navigates to a value behind an interpolated key using an interpolated value"' do
+          Puppet[:log_level] = 'debug'
+          collect_notices("notice('success')") do |scope|
+            scope['key'] = 'a_key'
+            scope['value'] = 'interpolated value'
+            expect(lookup_func.call(scope, 'b')).to eql('Detail in the interpolated value')
+          end
+          expect(notices).to eql(['success'])
+        end
+      end
+
+      context 'that is empty' do
+        let(:common_yaml) { '' }
+
+        it 'fails with a "did not find"' do
+          expect { lookup('a') }.to raise_error do |e|
+            expect(e.message).to match(/did not find a value for the name 'a'/)
+          end
+        end
+
+        it 'logs a warning that the file does not contain a hash' do
+          expect { lookup('a') }.to raise_error(Puppet::DataBinding::LookupError)
+          expect(warnings).to include(/spec\/data\/common.yaml: file does not contain a valid yaml hash/)
+        end
+      end
+
+      context 'that contains illegal yaml' do
+        let(:common_yaml) { "@!#%**&:\n" }
+
+        it 'fails lookup and that the key is not found' do
+          expect { lookup('a') }.to raise_error do |e|
+            expect(e.message).to match(/Unable to parse/)
+          end
+        end
+      end
+
+      context 'that contains a legal yaml that is not a hash' do
+        let(:common_yaml) { "- A list\n- of things" }
+
+        it 'fails with a "did not find"' do
+          expect { lookup('a') }.to raise_error do |e|
+            expect(e.message).to match(/did not find a value for the name 'a'/)
+          end
+        end
+
+        it 'logs a warning that the file does not contain a hash' do
+          expect { lookup('a') }.to raise_error(Puppet::DataBinding::LookupError)
+          expect(warnings).to include(/spec\/data\/common.yaml: file does not contain a valid yaml hash/)
+        end
+      end
+
+      context 'that contains a legal yaml hash with illegal types' do
+        let(:common_yaml) do
+          <<-YAML.unindent
+          ---
+          a: !ruby/object:Puppet::Graph::Key
+              value: x
+          YAML
+        end
+
+        it 'fails lookup and reports a type mismatch' do
+          expect { lookup('a') }.to raise_error do |e|
+            expect(e.message).to match(/wrong type, expects a value of type Scalar, Sensitive, Type, Hash, or Array, got Runtime/)
+          end
+        end
+      end
+    end
 
     context 'with lookup_options configured using patterns' do
       let(:mod_common) {
@@ -508,13 +669,39 @@ describe "The lookup function" do
             'hiera.yaml' => <<-YAML.unindent,
               ---
               :backends: yaml
-          YAML
+              :yaml:
+                :datadir:  #{env_dir}/#{env_name}/hieradata
+              YAML
+            'hieradata' => {
+              'common.yaml' => <<-YAML.unindent,
+                g: Value g
+                YAML
+            }
           }
         }
       end
 
-      it 'raises an error' do
-        expect { lookup('a') }.to raise_error(Puppet::Error, /hiera configuration version 3 cannot be used in an environment/)
+      it 'will raise an error if --strict is set to error' do
+        Puppet[:strict] = :error
+        expect { lookup('g') }.to raise_error(Puppet::Error, /hiera configuration version 3 cannot be used in an environment/)
+      end
+
+      it 'will log a warning and ignore the file if --strict is set to warning' do
+        Puppet[:strict] = :warning
+        expect { lookup('g') }.to raise_error(Puppet::Error, /did not find a value for the name 'g'/)
+      end
+
+      it 'will not log a warning and ignore the file if --strict is set to off' do
+        Puppet[:strict] = :off
+        expect { lookup('g') }.to raise_error(Puppet::Error, /did not find a value for the name 'g'/)
+        expect(warnings).to include(/hiera.yaml version 3 found at the environment root was ignored/)
+      end
+
+      it 'will use the configuration if appointed by global setting but still warn when encountered by environment data provider' do
+        Puppet[:strict] = :warning
+        Puppet.settings[:hiera_config] = File.join(env_dir, env_name, 'hiera.yaml')
+        expect(lookup('g')).to eql('Value g')
+        expect(warnings).to include(/hiera.yaml version 3 found at the environment root was ignored/)
       end
     end
 
@@ -582,35 +769,6 @@ describe "The lookup function" do
       let(:code_dir_files) do
         {
           'hiera.yaml' => hiera_yaml,
-          'ruby_stuff' => {
-            'hiera' => {
-              'backend' => {
-                'custom_backend.rb' => <<-RUBY.unindent,
-                  class Hiera::Backend::Custom_backend
-                    def lookup(key, scope, order_override, resolution_type, context)
-                      case key
-                      when 'hash_c'
-                        { 'hash_ca' => { 'cad' => 'value hash_c.hash_ca.cad (from global custom)' }}
-                      when 'datasources'
-                        Hiera::Backend.datasources(scope, order_override) { |source| source }
-                      else
-                        throw :no_such_key
-                      end
-                    end
-                  end
-                  RUBY
-                'other_backend.rb' => <<-RUBY.unindent,
-                  class Hiera::Backend::Other_backend
-                    def lookup(key, scope, order_override, resolution_type, context)
-                      value = Hiera::Config[:other][key.to_sym]
-                      throw :no_such_key if value.nil?
-                      value
-                    end
-                  end
-                  RUBY
-              }
-            }
-          },
           'hieradata' => {
             'common.yaml' =>  <<-YAML.unindent,
               a: value a (from global)
@@ -655,14 +813,16 @@ describe "The lookup function" do
       around(:each) do |example|
         # Faking the load path to enable 'require' to load from 'ruby_stuff'. It removes the need for a static fixture
         # for the custom backend
-        $LOAD_PATH.unshift(File.join(code_dir, 'ruby_stuff'))
+        $LOAD_PATH.unshift(populated_ruby_dir)
         begin
           Puppet.override(:environments => environments, :current_environment => env) do
             example.run
           end
         ensure
-          Hiera::Backend.send(:remove_const, :Custom_backend) if Hiera::Backend.const_defined?(:Custom_backend)
-          Hiera::Backend.send(:remove_const, :Other_backend) if Hiera::Backend.const_defined?(:Other_backend)
+          if Kernel.const_defined?(:Hiera) && Hiera.const_defined?(:Backend)
+            Hiera::Backend.send(:remove_const, :Custom_backend) if Hiera::Backend.const_defined?(:Custom_backend)
+            Hiera::Backend.send(:remove_const, :Other_backend) if Hiera::Backend.const_defined?(:Other_backend)
+          end
           $LOAD_PATH.shift
         end
       end
@@ -720,6 +880,150 @@ describe "The lookup function" do
           expect(lookup('xs.subkey')).to eql('value xs.subkey (from global hocon)')
         end
 
+        context 'using an eyaml backend' do
+          let(:private_key_name) { 'private_key.pkcs7.pem' }
+          let(:public_key_name) { 'public_key.pkcs7.pem' }
+
+          let(:private_key) do
+            <<-PKCS7.unindent
+              -----BEGIN RSA PRIVATE KEY-----
+              MIIEogIBAAKCAQEAwHB3GvImq59em4LV9DMfP0Zjs21eW3Jd5I9fuY0jLJhIkH6f
+              CR7tyOpYV6xUj+TF8giq9WLxZI7sourMJMWjEWhVjgUr5lqp1RLv4lwfDv3Wk4XC
+              2LUuqj1IAErUXKeRz8i3lUSZW1Pf4CaMpnIiPdWbz6f0KkaJSFi9bqexONBx4fKQ
+              NlgZwm2/aYjjrYng788I0QhWDKUqsQOi5mZKlHNRsDlk7J3Afhsx/jTLrCX/G8+2
+              tPtLsHyRN39kluM5vYHbKXDsCG/a88Z2yUE2+r4Clp0FUKffiEDBPm0/H0sQ4Q1o
+              EfQFDQRKaIkhpsm0nOnLYTy3/xJc5uqDNkLiawIDAQABAoIBAE98pNXOe8ab93oI
+              mtNZYmjCbGAqprTjEoFb71A3SfYbmK2Gf65GxjUdBwx/tBYTiuekSOk+yzKcDoZk
+              sZnmwKpqDByzaiSmAkxunANFxdZtZvpcX9UfUX0j/t+QCROUa5gF8j6HrUiZ5nkx
+              sxr1PcuItekaGLJ1nDLz5JsWTQ+H4M+GXQw7/t96x8v8g9el4exTiAHGk6Fv16kD
+              017T02M9qTTmV3Ab/enDIBmKVD42Ta36K/wc4l1aoUQNiRbIGVh96Cgd1CFXLF3x
+              CsaNbYT4SmRXaYqoj6MKq+QFEGxadFmJy48NoSd4joirIn2lUjHxJebw3lLbNLDR
+              uvQnQ2ECgYEA/nD94wEMr6078uMv6nKxPpNGq7fihwSKf0G/PQDqrRmjUCewuW+k
+              /iXMe1Y/y0PjFeNlSbUsUvKQ5xF7F/1AnpuPHIrn3cjGVLb71W+zen1m8SnhsW/f
+              7dPgtcb4SCvfhmLgoov+P34YcNfGi6qgPUu6319IqoB3BIi7PvfEomkCgYEAwZ4+
+              V0bMjFdDn2hnYzjTNcF2aUQ1jPvtuETizGwyCbbMLl9522lrjC2DrH41vvqX35ct
+              CBJkhQFbtHM8Gnmozv0vxhI2jP+u14mzfePZsaXuYrEgWRj+BCsYUHodXryxnEWj
+              yVrTNskab1B5jFm2SCJDmKcycBOYpRBLCMx6W7MCgYBA99z7/6KboOIzzKrJdGup
+              jLV410UyMIikoccQ7pD9jhRTPS80yjsY4dHqlEVJw5XSWvPb9DTTITi6p44EvBep
+              6BKMuTMnQELUEr0O7KypVCfa4FTOl8BX28f+4kU3OGykxc6R8qkC0VGwTohV1UWB
+              ITsgGhZV4uOA9uDI3T8KMQKBgEnQY2HwmuDSD/TA39GDA3qV8+ez2lqSXRGIKZLX
+              mMf9SaBQQ+uzKA4799wWDbVuYeIbB07xfCL83pJP8FUDlqi6+7Celu9wNp7zX1ua
+              Nw8z/ErhzjxJe+Xo7A8aTwIkG+5A2m1UU/up9YsEeiJYvVaIwY58B42U2vfq20BS
+              fD9jAoGAX2MscBzIsmN+U9R0ptL4SXcPiVnOl8mqvQWr1B4OLgxX7ghht5Fs956W
+              bHipxOWMFCPJA/AhNB8q1DvYiD1viZbIALSCJVUkzs4AEFIjiPsCBKxerl7jF6Xp
+              1WYSaCmfvoCVEpFNt8cKp4Gq+zEBYAV4Q6TkcD2lDtEW49MuN8A=
+              -----END RSA PRIVATE KEY-----
+              PKCS7
+          end
+
+          let(:public_key) do
+            <<-PKCS7.unindent
+              -----BEGIN CERTIFICATE-----
+              MIIC2TCCAcGgAwIBAgIBATANBgkqhkiG9w0BAQUFADAAMCAXDTE3MDExMzA5MTY1
+              MloYDzIwNjcwMTAxMDkxNjUyWjAAMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+              CgKCAQEAwHB3GvImq59em4LV9DMfP0Zjs21eW3Jd5I9fuY0jLJhIkH6fCR7tyOpY
+              V6xUj+TF8giq9WLxZI7sourMJMWjEWhVjgUr5lqp1RLv4lwfDv3Wk4XC2LUuqj1I
+              AErUXKeRz8i3lUSZW1Pf4CaMpnIiPdWbz6f0KkaJSFi9bqexONBx4fKQNlgZwm2/
+              aYjjrYng788I0QhWDKUqsQOi5mZKlHNRsDlk7J3Afhsx/jTLrCX/G8+2tPtLsHyR
+              N39kluM5vYHbKXDsCG/a88Z2yUE2+r4Clp0FUKffiEDBPm0/H0sQ4Q1oEfQFDQRK
+              aIkhpsm0nOnLYTy3/xJc5uqDNkLiawIDAQABo1wwWjAPBgNVHRMBAf8EBTADAQH/
+              MB0GA1UdDgQWBBSejWrVnw7QaBjNFCHMNFi+doSOcTAoBgNVHSMEITAfgBSejWrV
+              nw7QaBjNFCHMNFi+doSOcaEEpAIwAIIBATANBgkqhkiG9w0BAQUFAAOCAQEAAe85
+              BQ1ydAHFqo0ib38VRPOwf5xPHGbYGhvQi4/sU6aTuR7pxaOJPYz05jLhS+utEmy1
+              sknBq60G67yhQE7IHcfwrl1arirG2WmKGvAbjeYL2K1UiU0pVD3D+Klkv/pK6jIQ
+              eOJRGb3qNUn0Sq9EoYIOXiGXQ641F0bZZ0+5H92kT1lmnF5oLfCb84ImD9T3snH6
+              pIr5RKRx/0YmJIcv3WdpoPT903rOJiRIEgIj/hDk9QZTBpm222Ul5yQQ5pBywpSp
+              xh0bmJKAQWhQm7QlybKfyaQmg5ot1jEzWAvD2I5FjHQxmAlchjb6RreaRhExj+JE
+              5O117dMBdzDBjcNMOA==
+              -----END CERTIFICATE-----
+              PKCS7
+          end
+
+          let(:keys_dir) do
+            keys = tmpdir('keys')
+            dir_contained_in(keys, {
+              private_key_name => private_key,
+              public_key_name => public_key
+            })
+            keys
+          end
+
+          let(:private_key_path) { File.join(keys_dir, private_key_name) }
+          let(:public_key_path) { File.join(keys_dir, public_key_name) }
+          let(:hiera_yaml) do
+            <<-YAML.unindent
+            :backends:
+              - eyaml
+              - yaml
+            :eyaml:
+              :datadir: #{code_dir}/hieradata
+              :pkcs7_private_key: #{private_key_path}
+              :pkcs7_public_key: #{public_key_path}
+            :yaml:
+              :datadir: #{code_dir}/hieradata
+            :hierarchy:
+              - common
+           YAML
+          end
+
+          let(:data_files) do
+            {
+              'common.yaml' => <<-YAML.unindent,
+                b: value 'b' (from global)
+                c:
+                  c_a: value c_a (from global)
+                YAML
+              '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=]
+                a_ref: "A reference to %{hiera('a')}"
+                b_ref: "A reference to %{hiera('b')}"
+                c_ref: "%{alias('c')}"
+                YAML
+            }
+          end
+
+          let(:code_dir_files) do
+            {
+              'hiera.yaml' => hiera_yaml,
+              'hieradata' => data_files
+            }
+          end
+
+          before(:each) do
+            Puppet.settings[:hiera_config] = File.join(code_dir, 'hiera.yaml')
+          end
+
+          it 'finds data in the global layer' do
+            expect(lookup('a')).to eql("Encrypted value 'a' (from global)")
+          end
+
+          it 'can use a hiera interpolation' do
+            expect(lookup('a_ref')).to eql("A reference to Encrypted value 'a' (from global)")
+          end
+
+          it 'can use a hiera interpolation that refers back to yaml' do
+            expect(lookup('b_ref')).to eql("A reference to value 'b' (from global)")
+          end
+
+          it 'can use a hiera interpolation that refers back to yaml, but only in global layer' do
+            expect(lookup(['c', 'c_ref'], 'merge' => 'deep')).to eql([{'c_a' => 'value c_a (from global)', 'c_b' => 'value c_b (from environment)'}, { 'c_a' => 'value c_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
+
         context 'using deep_merge_options supported by deep_merge gem but not supported by Puppet' do
 
           let(:hiera_yaml) do
@@ -743,20 +1047,69 @@ describe "The lookup function" do
               'hiera.yaml' => hiera_yaml,
               'hieradata' => {
                 'common.yaml' => <<-YAML.unindent,
-                  a:
+                  h:
                     - x1,x2
+                  str: a string
+                  mixed:
+                    x: hx
+                    y: hy
                   YAML
                 'other.yaml' => <<-YAML.unindent,
-                  a:
+                  h:
                     - x3
                     - x4
+                  str: another string
+                  mixed:
+                    - h1
+                    - h2
                   YAML
               }
             }
           end
 
           it 'honors option :unpack_arrays: (unsupported by puppet)' do
-            expect(lookup('a')).to eql(%w(x1 x2 x3 x4))
+            expect(lookup('h')).to eql(%w(x1 x2 x3 x4))
+          end
+
+          it 'will treat merge of strings as a unique (first found)' do
+            expect(lookup('str')).to eql('another string')
+          end
+
+          it 'will treat merge of array and hash as a unique (first found)' do
+            expect(lookup('mixed')).to eql(%w(h1 h2))
+          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
           end
         end
 

data/spec/unit/network/http/factory_spec.rb

@@ -4,6 +4,10 @@ require 'puppet/network/http'
 require 'puppet/util/http_proxy'
 
 describe Puppet::Network::HTTP::Factory do
+  before(:all) do
+    ENV['http_proxy'] = nil
+    ENV['HTTP_PROXY'] = nil
+  end
   before :each do
     Puppet::SSL::Key.indirection.terminus_class = :memory
     Puppet::SSL::CertificateRequest.indirection.terminus_class = :memory

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -29,6 +29,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     @scope = Puppet::Parser::Scope.new(@compiler)
     @scope.source = Puppet::Resource::Type.new(:node, 'node.example.com')
     @scope.parent = @compiler.topscope
+    Puppet.push_context(:loaders => @compiler.loaders)
+  end
+
+  after(:each) do
+    Puppet.pop_context
   end
 
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }

data/spec/unit/pops/evaluator/evaluator_rspec_helper.rb

@@ -23,18 +23,20 @@ module EvaluatorRspecHelper
     # top_scope = Puppet::Parser::Scope.new(compiler)
 
     evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
-    result = evaluator.evaluate(in_top_scope.current, top_scope)
-    if in_named_scope
-      other_scope = Puppet::Parser::Scope.new(compiler, :namespace => scopename)
-      result = evaluator.evaluate(in_named_scope.current, other_scope)
-    end
-    if in_top_scope_again
-      result = evaluator.evaluate(in_top_scope_again.current, top_scope)
-    end
-    if block_given?
-      block.call(top_scope)
+    Puppet.override(:loaders => compiler.loaders) do
+      result = evaluator.evaluate(in_top_scope.current, top_scope)
+      if in_named_scope
+        other_scope = Puppet::Parser::Scope.new(compiler, :namespace => scopename)
+        result = evaluator.evaluate(in_named_scope.current, other_scope)
+      end
+      if in_top_scope_again
+        result = evaluator.evaluate(in_top_scope_again.current, top_scope)
+      end
+      if block_given?
+        block.call(top_scope)
+      end
+      result
     end
-    result
   end
 
   # Evaluate a Factory wrapper round a model object in top scope + local scope
@@ -52,20 +54,22 @@ module EvaluatorRspecHelper
     top_scope = compiler.topscope()
 
     evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
-    result = evaluator.evaluate(in_top_scope.current, top_scope)
-    if in_local_scope
-      # This is really bad in 3.x scope
-      top_scope.with_guarded_scope do
-        top_scope.new_ephemeral(true)
-        result = evaluator.evaluate(in_local_scope.current, top_scope)
+    Puppet.override(:loaders => compiler.loaders) do
+      result = evaluator.evaluate(in_top_scope.current, top_scope)
+      if in_local_scope
+        # This is really bad in 3.x scope
+        top_scope.with_guarded_scope do
+          top_scope.new_ephemeral(true)
+          result = evaluator.evaluate(in_local_scope.current, top_scope)
+        end
       end
+      if in_top_scope_again
+        result = evaluator.evaluate(in_top_scope_again.current, top_scope)
+      end
+      if block_given?
+        block.call(top_scope)
+      end
+      result
     end
-    if in_top_scope_again
-      result = evaluator.evaluate(in_top_scope_again.current, top_scope)
-    end
-    if block_given?
-      block.call(top_scope)
-    end
-    result
   end
 end