puppet 4.8.2-x64-mingw32 → 4.9.0-x64-mingw32

data/spec/unit/pops/lookup/context_spec.rb

@@ -37,6 +37,14 @@ describe 'Puppet::Pops::Lookup::Context' do
       expect(eval_and_collect_notices(code)[0]).to eql('ze_value')
     end
 
+    it 'the cache method returns the value that is cached' do
+      code = <<-PUPPET.unindent
+        $ctx = Puppet::LookupContext.new('e', 'm')
+        notice($ctx.cache('ze_key', 'ze_value'))
+      PUPPET
+      expect(eval_and_collect_notices(code)[0]).to eql('ze_value')
+    end
+
     it 'can store and retrieve a hash using the cache' do
       code = <<-PUPPET.unindent
         $ctx = Puppet::LookupContext.new('e', 'm')
@@ -115,35 +123,56 @@ describe 'Puppet::Pops::Lookup::Context' do
     end
 
     context 'when used in an Invocation' do
-      let(:invocation) { Invocation.new({}) }
-      let(:invocation_with_explain) { Invocation.new({}, {}, {}, true) }
+      let(:node) { Puppet::Node.new('test') }
+      let(:compiler) { Puppet::Parser::Compiler.new(node) }
+      let(:invocation) { Invocation.new(compiler.topscope) }
+      let(:invocation_with_explain) { Invocation.new(compiler.topscope, {}, {}, true) }
+
+      def compile_and_get_notices(code, scope_vars = {})
+        Puppet[:code] = code
+        scope = compiler.topscope
+        scope_vars.each_pair { |k,v| scope.setvar(k, v) }
+        node.environment.check_for_reparse
+        logs = []
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          compiler.compile
+        end
+        logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
+        logs
+      end
 
       it 'will not call explain unless explanations are active' do
-        Invocation.expects(:current).returns(invocation)
-        code = <<-PUPPET.unindent
-          $ctx = Puppet::LookupContext.new('e', 'm')
-          $ctx.explain || { notice('stop calling'); 'bad' }
-        PUPPET
-        expect(eval_and_collect_notices(code)).to be_empty
+        invocation.lookup('dummy', nil) do
+          code = <<-PUPPET.unindent
+            $ctx = Puppet::LookupContext.new('e', 'm')
+            $ctx.explain || { notice('stop calling'); 'bad' }
+          PUPPET
+          expect(compile_and_get_notices(code)).to be_empty
+        end
       end
 
       it 'will call explain when explanations are active' do
-        Invocation.expects(:current).returns(invocation_with_explain)
-        invocation_with_explain.with(:global, 'test') do
+        invocation_with_explain.lookup('dummy', nil) do
           code = <<-PUPPET.unindent
             $ctx = Puppet::LookupContext.new('e', 'm')
             $ctx.explain || { notice('called'); 'good' }
           PUPPET
-          expect(eval_and_collect_notices(code)).to eql(['called'])
+          expect(compile_and_get_notices(code)).to eql(['called'])
+        end
+        expect(invocation_with_explain.explainer.explain).to eql("good\n")
+      end
+
+      it 'will call interpolate to resolve interpolation' do
+        invocation.lookup('dummy', nil) do
+          code = <<-PUPPET.unindent
+            $ctx = Puppet::LookupContext.new('e', 'm')
+            notice($ctx.interpolate('-- %{testing} --'))
+          PUPPET
+          expect(compile_and_get_notices(code, { 'testing' => 'called' })).to eql(['-- called --'])
         end
-        expect(invocation_with_explain.explainer.to_s).to eql(<<-TEXT.unindent)
-          Data Binding "test"
-            good
-        TEXT
       end
     end
   end
 end
 end
 end
-

data/spec/unit/pops/lookup/interpolation_spec.rb

@@ -1,18 +1,23 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet'
-require 'puppet/data_providers/hiera_config'
-require 'puppet/data_providers/hiera_interpolate'
 
 module Puppet::Pops
 describe 'Puppet::Pops::Lookup::Interpolation' do
+  include Lookup::SubLookup
 
   let(:interpolator) { Class.new { include Lookup::Interpolation }.new }
   let(:scope) { {} }
   let(:lookup_invocation) { Lookup::Invocation.new(scope, {}, {}, nil) }
 
   def expect_lookup(*keys)
-    keys.each { |key| Lookup.expects(:lookup).with(key, nil, '', true, nil, lookup_invocation).returns(data[key]) }
+    keys.each do |key|
+      segments = split_key(key)
+      root_key = segments.shift
+      found = data[root_key]
+      found = sub_lookup(key, lookup_invocation, segments, found) unless segments.empty?
+      Lookup.expects(:lookup).with(key, nil, '', true, nil, lookup_invocation).returns(found)
+    end
   end
 
   context 'when interpolating nested data' do
@@ -160,12 +165,12 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should find an entry using a quoted interpolation with method lookup' do
-      expect_lookup('a.b')
+      expect_lookup("'a.b'")
       expect(interpolator.interpolate("a dot c: %{lookup(\"'a.b'\")}", lookup_invocation, true)).to eq('a dot c: (lookup) a dot b')
     end
 
     it 'should find an entry using a quoted interpolation with method alias' do
-      expect_lookup('a.b')
+      expect_lookup("'a.b'")
       expect(interpolator.interpolate("%{alias(\"'a.b'\")}", lookup_invocation, true)).to eq('(lookup) a dot b')
     end
 
@@ -173,8 +178,12 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
       expect(interpolator.interpolate('a dot e: %{a.d}', lookup_invocation, true)).to eq('a dot e: (scope) a dot d is a hash entry')
     end
 
-    it 'should use a dotted key to navigate into a structure when when it is not quoted with method lookup' do
-      expect_lookup('a')
+    it 'should report a key missing and replace with empty string when a dotted key is used to navigate into a structure and then not found' do
+      expect(interpolator.interpolate('a dot n: %{a.n}', lookup_invocation, true)).to eq('a dot n: ')
+    end
+
+    it 'should use a dotted key to navigate into a structure when it is not quoted with method lookup' do
+      expect_lookup('a.d')
       expect(interpolator.interpolate("a dot e: %{lookup('a.d')}", lookup_invocation, true)).to eq('a dot e: (lookup) a dot d is a hash entry')
     end
 
@@ -183,7 +192,7 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is last and method is lookup' do
-      expect_lookup('a')
+      expect_lookup("a.'d.x'")
       expect(interpolator.interpolate("a dot ex: %{lookup(\"a.'d.x'\")}", lookup_invocation, true)).to eq('a dot ex: (lookup) a dot d.x is a hash entry')
     end
 
@@ -192,7 +201,7 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is first and method is lookup' do
-      expect_lookup('a.x')
+      expect_lookup("'a.x'.d")
       expect(interpolator.interpolate("a dot xe: %{lookup(\"'a.x'.d\")}", lookup_invocation, true)).to eq('a dot xe: (lookup) a.x dot d is a hash entry')
     end
 
@@ -201,7 +210,7 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is in the middle and method is lookup' do
-      expect_lookup('a')
+      expect_lookup("a.'d.z'.g")
       expect(interpolator.interpolate("a dot xm: %{lookup(\"a.'d.z'.g\")}", lookup_invocation, true)).to eq('a dot xm: (lookup) a dot d.z dot g is a hash entry')
     end
 
@@ -210,7 +219,7 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should use a mix of several quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is in the middle and method is lookup' do
-      expect_lookup('a.x')
+      expect_lookup("'a.x'.'d.z'.g")
       expect(interpolator.interpolate("a dot xx: %{lookup(\"'a.x'.'d.z'.g\")}", lookup_invocation, true)).to eq('a dot xx: (lookup) a.x dot d.z dot g is a hash entry')
     end
 
@@ -219,7 +228,7 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should find an entry using using a quoted interpolation on dotted key containing numbers using method lookup' do
-      expect_lookup('x.1')
+      expect_lookup("'x.1'")
       expect(interpolator.interpolate("x dot 2: %{lookup(\"'x.1'\")}", lookup_invocation, true)).to eq('x dot 2: (lookup) x dot 1')
     end
 
@@ -228,13 +237,12 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should not find a subkey when the dotted key is quoted with method lookup' do
-      expect_lookup('a.d')
+      expect_lookup("'a.d'")
       expect(interpolator.interpolate("a dot f: %{lookup(\"'a.d'\")}", lookup_invocation, true)).to eq('a dot f: ')
     end
 
     it 'should not find a subkey that is matched within a string' do
-      expect_lookup('key')
-      expect{ interpolator.interpolate('%{hiera("key.subkey")}', lookup_invocation, true) }.to raise_error(/Got String when a hash-like object was expected to access value using 'subkey' from key 'key.subkey'/)
+      expect{ expect_lookup('key.subkey') }.to raise_error(/Got String when a hash-like object was expected to access value using 'subkey' from key 'key.subkey'/)
     end
   end
 
@@ -267,27 +275,27 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'allows dotted keys with non alphanumeric characters' do
-      expect_lookup('very_angry', '!$\%!')
+      expect_lookup('very_angry', '!$\%!.\#@!&%|')
       expect(interpolator.interpolate("%{lookup('very_angry')}", lookup_invocation, true)).to eq('not happy at all')
     end
 
     it 'allows dotted keys with nested white space' do
-      expect_lookup('a key with')
+      expect_lookup('a key with.nested whitespace')
       expect(interpolator.interpolate("%{lookup('a key with.nested whitespace')}", lookup_invocation, true)).to eq('value for nested ws key')
     end
 
     it 'will trim each key element' do
-      expect_lookup('a key with')
+      expect_lookup(' a key with . nested whitespace ')
       expect(interpolator.interpolate("%{lookup(' a key with . nested whitespace ')}", lookup_invocation, true)).to eq('value for nested ws key')
     end
 
     it 'will not trim quoted key element' do
-      expect_lookup('a key with')
+      expect_lookup(' a key with ." untrimmed whitespace "')
       expect(interpolator.interpolate("%{lookup(' a key with .\" untrimmed whitespace \"')}", lookup_invocation, true)).to eq('value for untrimmed ws key')
     end
 
     it 'will not trim spaces outside of quoted key element' do
-      expect_lookup('a key with')
+      expect_lookup(' a key with .  " untrimmed whitespace "  ')
       expect(interpolator.interpolate("%{lookup(' a key with .  \" untrimmed whitespace \"  ')}", lookup_invocation, true)).to eq('value for untrimmed ws key')
     end
   end

data/spec/unit/pops/lookup/lookup_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/pops'
+require 'deep_merge/core'
+
+module Puppet::Pops
+module Lookup
+describe 'The lookup API' do
+  include PuppetSpec::Files
+
+  let(:env_name) { 'spec' }
+  let(:code_dir) { Puppet[:environmentpath] }
+  let(:env_dir) { File.join(code_dir, env_name) }
+  let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, 'modules')]) }
+  let(:node) { Puppet::Node.new('test', :environment => env) }
+  let(:compiler) { Puppet::Parser::Compiler.new(node) }
+  let(:scope) { compiler.topscope }
+  let(:invocation) { Invocation.new(scope) }
+
+  let(:code_dir_content) do
+    {
+      'hiera.yaml' => <<-YAML.unindent,
+        version: 5
+        YAML
+      'data' => {
+        'common.yaml' => <<-YAML.unindent
+          a: a (from global)
+          d: d (from global)
+          mod::e: mod::e (from global)
+          YAML
+      }
+    }
+  end
+
+  let(:env_content) do
+    {
+      'hiera.yaml' => <<-YAML.unindent,
+        version: 5
+        YAML
+      'data' => {
+        'common.yaml' => <<-YAML.unindent
+          b: b (from environment)
+          d: d (from environment)
+          mod::f: mod::f (from environment)
+          YAML
+      }
+    }
+  end
+
+  let(:mod_content) do
+    {
+      'hiera.yaml' => <<-YAML.unindent,
+        version: 5
+        YAML
+      'data' => {
+        'common.yaml' => <<-YAML.unindent
+          mod::c: mod::c (from module)
+          mod::e: mod::e (from module)
+          mod::f: mod::f (from module)
+          YAML
+      }
+    }
+  end
+
+  let(:populated_env_dir) do
+    all_content = code_dir_content.merge(env_name => env_content.merge('modules' => { 'mod' => mod_content }))
+    dir_contained_in(code_dir, all_content)
+    all_content.keys.each { |key| PuppetSpec::Files.record_tmp(File.join(code_dir, key)) }
+    env_dir
+  end
+
+  before(:each) do
+    Puppet[:hiera_config] = File.join(code_dir, 'hiera.yaml')
+    Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))
+  end
+
+  after(:each) do
+    Puppet.pop_context
+  end
+
+  context 'when doing lookup' do
+    it 'finds data in global layer' do
+      expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
+    end
+
+    it 'finds data in environment layer' do
+      expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('b (from environment)')
+    end
+
+    it 'global layer wins over environment layer' do
+      expect(Lookup.lookup('d', nil, 'not found', true, nil, invocation)).to eql('d (from global)')
+    end
+
+    it 'finds data in module layer' do
+      expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('mod::c (from module)')
+    end
+
+    it 'global layer wins over module layer' do
+      expect(Lookup.lookup('mod::e', nil, 'not found', true, nil, invocation)).to eql('mod::e (from global)')
+    end
+
+    it 'environment layer wins over module layer' do
+      expect(Lookup.lookup('mod::f', nil, 'not found', true, nil, invocation)).to eql('mod::f (from environment)')
+    end
+
+    context "with 'global_only' set to true in the invocation" do
+      let(:invocation) { Invocation.new(scope).set_global_only }
+
+      it 'finds data in global layer' do
+        expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
+      end
+
+      it 'does not find data in environment layer' do
+        expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('not found')
+      end
+
+      it 'does not find data in module layer' do
+        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('not found')
+      end
+    end
+
+    context "with 'global_only' set to true in the lookup adapter" do
+      it 'finds data in global layer' do
+        invocation.lookup_adapter.set_global_only
+        expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
+      end
+
+      it 'does not find data in environment layer' do
+        invocation.lookup_adapter.set_global_only
+        expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('not found')
+      end
+
+      it 'does not find data in module layer' do
+        invocation.lookup_adapter.set_global_only
+        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('not found')
+      end
+    end
+
+    context 'with subclassed lookup adpater' do
+      let(:other_dir) { tmpdir('other') }
+      let(:other_dir_content) do
+        {
+          'hiera.yaml' => <<-YAML.unindent,
+            version: 5
+            YAML
+          'data' => {
+            'common.yaml' => <<-YAML.unindent
+              a: a (from other global)
+              d: d (from other global)
+              mod::e: mod::e (from other global)
+              YAML
+          }
+        }
+      end
+
+      let(:populated_other_dir) do
+        dir_contained_in(other_dir, other_dir_content)
+        other_dir
+      end
+
+      before(:each) do
+        eval(<<-RUBY.unindent)
+        class SpecialLookupAdapter < LookupAdapter
+           def initialize(compiler)
+             super
+             set_global_only
+             set_global_hiera_config_path(File.join('#{populated_other_dir}', 'hiera.yaml'))
+           end
+        end
+        RUBY
+      end
+
+      after(:each) do
+        Puppet::Pops::Lookup.send(:remove_const, :SpecialLookupAdapter)
+      end
+
+      let(:other_invocation) { Invocation.new(scope, EMPTY_HASH, EMPTY_HASH, nil, SpecialLookupAdapter) }
+
+      it 'finds different data in global layer' do
+        expect(Lookup.lookup('a', nil, nil, false, nil, other_invocation)).to eql('a (from other global)')
+        expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
+      end
+
+      it 'does not find data in environment layer' do
+        expect(Lookup.lookup('b', nil, 'not found', true, nil, other_invocation)).to eql('not found')
+        expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('b (from environment)')
+      end
+
+      it 'does not find data in module layer' do
+        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, other_invocation)).to eql('not found')
+        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('mod::c (from module)')
+      end
+    end
+  end
+end
+end
+end

data/spec/unit/pops/merge_strategy_spec.rb

@@ -0,0 +1,18 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops
+describe 'MergeStrategy' do
+  context 'deep merge' do
+    it 'does not mutate the source of a merge' do
+      a = { 'a' => { 'b' => 'va' }, 'c' => 2 }
+      b = { 'a' => { 'b' => 'vb' }, 'b' => 3}
+      c = MergeStrategy.strategy(:deep).merge(a, b);
+      expect(a).to eql({ 'a' => { 'b' => 'va' }, 'c' => 2 })
+      expect(b).to eql({ 'a' => { 'b' => 'vb' }, 'b' => 3 })
+      expect(c).to eql({ 'a' => { 'b' => 'va' }, 'b' => 3, 'c' => 2 })
+    end
+  end
+end
+end