puppet 4.0.0 → 4.9.1

data/spec/unit/functions/hiera_spec.rb

@@ -1,123 +1,335 @@
 require 'spec_helper'
-require 'puppet_spec/scope'
+require 'puppet_spec/compiler'
 require 'puppet/pops'
-require 'puppet/loaders'
 
 describe 'when calling' do
-  include PuppetSpec::Scope
+  include PuppetSpec::Compiler
+  include PuppetSpec::Files
 
-  let(:scope) { create_test_scope_for_node('foo') }
-  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
-  let(:loader) { loaders.puppet_system_loader }
+  let(:global_dir) { tmpdir('global') }
+  let(:env_config) { {} }
+  let(:global_files) do
+    {
+      'hiera.yaml' => <<-YAML.unindent,
+        ---
+        :backends:
+          - yaml
+          - custom
+        :yaml:
+          :datadir: #{global_dir}/hieradata
+        :hierarchy:
+          - first
+          - second
+        YAML
+      'ruby_stuff' => {
+        'hiera' => {
+          'backend' => {
+            'custom_backend.rb' => <<-RUBY.unindent
+                    class Hiera::Backend::Custom_backend
+                      def initialize(cache = nil)
+                        Hiera.debug('Custom_backend starting')
+                      end
+      
+                      def lookup(key, scope, order_override, resolution_type, context)
+                        case key
+                        when 'datasources'
+                          Hiera::Backend.datasources(scope, order_override) { |source| source }
+                        else
+                          throw :no_such_key
+                        end
+                      end
+                    end
+              RUBY
+          }
+        }
+      },
+      'hieradata' => {
+        'first.yaml' => <<-YAML.unindent,
+                ---
+                a: first a
+                class_name: "-- %{calling_class} --"
+                class_path: "-- %{calling_class_path} --"
+                module: "-- %{calling_module} --"
+                mod_name: "-- %{module_name} --"
+                database_user:
+                  name: postgres
+                  uid: 500
+                  gid: 500
+                b:
+                  b1: first b1
+                  b2: first b2
+                fbb:
+                  - mod::foo
+                  - mod::bar
+                  - mod::baz
+                empty_array: []
+          YAML
+        'second.yaml' => <<-YAML.unindent,
+          ---
+          a: second a
+          b:
+            b1: second b1
+            b3: second b3
+          YAML
+        'the_override.yaml' => <<-YAML.unindent
+          ---
+          key: foo_result
+          YAML
+      },
+      'environments' => {
+        'test' => {
+          'modules' => {
+            'mod' => {
+              'manifests' => {
+                'foo.pp' => <<-PUPPET.unindent,
+                    class mod::foo {
+                      notice(hiera('class_name'))
+                      notice(hiera('class_path'))
+                      notice(hiera('module'))
+                      notice(hiera('mod_name'))
+                    }
+                  PUPPET
+                'bar.pp' => <<-PUPPET.unindent,
+                    class mod::bar {}
+                  PUPPET
+                'baz.pp' => <<-PUPPET.unindent
+                     class mod::baz {}
+                  PUPPET
+              },
+              'hiera.yaml' => <<-YAML.unindent,
+                ---
+                version: 5
+                YAML
+              'data' => {
+                 'common.yaml' => <<-YAML.unindent
+                    mod::c: mod::c (from module)
+                  YAML
+              }
+            }
+          }
+        }
+      }
+    }
+  end
 
-  context 'hiera' do
-    let(:hiera) { loader.load(:function, 'hiera') }
+  let(:logs) { [] }
+  let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+  let(:env_dir) { File.join(global_dir, 'environments') }
+  let(:env) { Puppet::Node::Environment.create(:test, [File.join(env_dir, 'test', 'modules')]) }
+  let(:environments) { Puppet::Environments::Directories.new(env_dir, []) }
+  let(:node) { Puppet::Node.new('test_hiera', :environment => env) }
+  let(:compiler) { Puppet::Parser::Compiler.new(node) }
+  let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera') }
+
+  before(:each) do
+    Puppet.settings[:codedir] = global_dir
+    Puppet.settings[:hiera_config] = File.join(global_dir, 'hiera.yaml')
+  end
+
+  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
+    dir_contained_in(global_dir, DeepMerge.deep_merge!(global_files, { 'environments' => { 'test' => env_config } } ))
+    $LOAD_PATH.unshift(File.join(global_dir, 'ruby_stuff'))
+    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)
+      $LOAD_PATH.shift
+    end
+  end
+
+  def with_scope(code = 'undef')
+    result = nil
+    Puppet[:code] = 'undef'
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      compiler.topscope['environment'] = 'test'
+      compiler.compile do |catalog|
+        result = yield(compiler.topscope)
+        catalog
+      end
+    end
+    result
+  end
 
+  def func(*args, &block)
+    with_scope { |scope| the_func.call(scope, *args, &block) }
+  end
+
+  context 'hiera' do
     it 'should require a key argument' do
-      expect { hiera.call(scope, []) }.to raise_error(ArgumentError)
+      expect { func([]) }.to raise_error(ArgumentError)
     end
 
     it 'should raise a useful error when nil is returned' do
-      expect { hiera.call(scope, 'badkey') }.to raise_error(Puppet::ParseError, /Could not find data item badkey/)
+      expect { func('badkey') }.to raise_error(Puppet::DataBinding::LookupError, /did not find a value for the name 'badkey'/)
     end
 
-    it 'should use the priority resolution_type' do
-      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[4]).to be(:priority) }.returns('foo_result')
-      expect(hiera.call(scope, 'key')).to eql('foo_result')
+    it 'should use the "first" merge strategy' do
+      expect(func('a')).to eql('first a')
     end
 
-    it 'should propagate optional default' do
-      dflt = 'the_default'
-      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[1]).to be(dflt) }.returns('foo_result')
-      expect(hiera.call(scope, 'key', dflt)).to eql('foo_result')
+    it 'should not find data in module' do
+      expect(func('mod::c', 'default mod::c')).to eql('default mod::c')
     end
 
     it 'should propagate optional override' do
       ovr = 'the_override'
-      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[3]).to be(ovr) }.returns('foo_result')
-      expect(hiera.call(scope, 'key', nil, ovr)).to eql('foo_result')
+      expect(func('key', nil, ovr)).to eql('foo_result')
+    end
+
+    it 'backend data sources, including optional overrides, are propagated to custom backend' do
+      expect(func('datasources', nil, 'the_override')).to eql(['the_override', 'first', 'second'])
+    end
+
+    it 'a hiera v3 scope is used' do
+      expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['-- testing --', '-- mod::foo --', '-- mod/foo --', '-- mod --', '-- mod --'])
+      class testing () {
+         notice(hiera('class_name'))
+      }
+      include testing
+      include mod::foo
+      PUPPET
+    end
+
+    it 'should return default value nil when key is not found' do
+       expect(func('foo', nil)).to be_nil
+    end
+
+    it "should return default value '' when key is not found" do
+      expect(func('foo', '')).to eq('')
     end
 
     it 'should use default block' do
-      #expect(hiera.call(scope, 'foo', lambda_1(scope, loader) { |k| "default for key '#{k}'" })).to eql("default for key 'foo'")
-      expect(hiera.call(scope, 'foo') { |k| "default for key '#{k}'" }).to eql("default for key 'foo'")
+      expect(func('foo') { |k| "default for key '#{k}'" }).to eql("default for key 'foo'")
     end
 
     it 'should propagate optional override when combined with default block' do
-      ovr = {}
-      Hiera::Backend::Yaml_backend.any_instance.expects(:lookup).with { |*args| expect(args[2]).to be(ovr) }.returns(nil)
-      expect(hiera.call(scope, 'foo.bar', ovr) { |k| "default for key '#{k}'" }).to eql("default for key 'foo.bar'")
+      ovr = 'the_override'
+      with_scope do |scope|
+        expect(the_func.call(scope, 'key', ovr) { |k| "default for key '#{k}'" }).to eql('foo_result')
+        expect(the_func.call(scope, 'foo.bar', ovr) { |k| "default for key '#{k}'" }).to eql("default for key 'foo.bar'")
+      end
+    end
+
+    it 'should log deprecation errors' do
+      func('a')
+      expect(warnings).to include(/The function 'hiera' is deprecated in favor of using 'lookup'. See https:/)
+    end
+
+    context 'with environment with configured data provider' do
+      let(:env_config) {
+        {
+          'hiera.yaml' => <<-YAML.unindent,
+             ---
+             version: 5
+             YAML
+          'data' => {
+            'common.yaml' => <<-YAML.unindent
+              ---
+              a: a (from environment)
+              e: e (from environment)
+              YAML
+          }
+        }
+      }
+
+      it 'should find data globally' do
+        expect(func('a')).to eql('first a')
+      end
+
+      it 'should find data in the environment' do
+        expect(func('e')).to eql('e (from environment)')
+      end
+
+      it 'should find data in module' do
+        expect(func('mod::c')).to eql('mod::c (from module)')
+      end
     end
   end
 
   context 'hiera_array' do
-    # noinspection RubyResolve
-    let(:hiera_array) { loader.load(:function, 'hiera_array') }
+    let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera_array') }
 
     it 'should require a key argument' do
-      expect { hiera_array.call(scope, []) }.to raise_error(ArgumentError)
+      expect { func([]) }.to raise_error(ArgumentError)
     end
 
     it 'should raise a useful error when nil is returned' do
-      expect { hiera_array.call(scope, 'badkey') }.to raise_error(Puppet::ParseError, /Could not find data item badkey/)
+      expect { func('badkey') }.to raise_error(Puppet::DataBinding::LookupError, /did not find a value for the name 'badkey'/)
+    end
+
+    it 'should log deprecation errors' do
+      func('fbb')
+      expect(warnings).to include(/The function 'hiera_array' is deprecated in favor of using 'lookup'/)
     end
 
     it 'should use the array resolution_type' do
-      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[4]).to be(:array) }.returns(%w[foo bar baz])
-      expect(hiera_array.call(scope, 'key', {'key' => 'foo_result'})).to eql(%w[foo bar baz])
+      expect(func('fbb', {'fbb' => 'foo_result'})).to eql(%w[mod::foo mod::bar mod::baz])
     end
 
     it 'should use default block' do
-      expect(hiera_array.call(scope, 'foo') { |k| ['key', k] }).to eql(%w[key foo])
+      expect(func('foo') { |k| ['key', k] }).to eql(%w[key foo])
     end
   end
 
   context 'hiera_hash' do
-    let(:hiera_hash) { loader.load(:function, 'hiera_hash') }
+    let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera_hash') }
 
     it 'should require a key argument' do
-      expect { hiera_hash.call(scope, []) }.to raise_error(ArgumentError)
+      expect { func([]) }.to raise_error(ArgumentError)
     end
 
     it 'should raise a useful error when nil is returned' do
-      expect { hiera_hash.call(scope, 'badkey') }.to raise_error(Puppet::ParseError, /Could not find data item badkey/)
+      expect { func('badkey') }.to raise_error(Puppet::DataBinding::LookupError, /did not find a value for the name 'badkey'/)
     end
 
     it 'should use the hash resolution_type' do
-      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[4]).to be(:hash) }.returns({'foo' => 'result'})
-      expect(hiera_hash.call(scope, 'key', {'key' => 'foo_result'})).to eql({'foo' => 'result'})
+      expect(func('b', {'b' => 'foo_result'})).to eql({ 'b1' => 'first b1', 'b2' => 'first b2', 'b3' => 'second b3'})
+    end
+
+    it 'should lookup and return a hash' do
+      expect(func('database_user')).to eql({ 'name' => 'postgres', 'uid' => 500, 'gid' => 500})
+    end
+
+    it 'should log deprecation errors' do
+      func('b')
+      expect(warnings).to include(/The function 'hiera_hash' is deprecated in favor of using 'lookup'. See https:/)
     end
 
     it 'should use default block' do
-      expect(hiera_hash.call(scope, 'foo') { |k| {'key' => k} }).to eql({'key' => 'foo'})
+      expect(func('foo') { |k| {'key' => k} }).to eql({'key' => 'foo'})
     end
   end
 
   context 'hiera_include' do
-    let(:hiera_include) { loader.load(:function, 'hiera_include') }
+    let(:the_func) { Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'hiera_include') }
 
     it 'should require a key argument' do
-      expect { hiera_include.call(scope, []) }.to raise_error(ArgumentError)
+      expect { func([]) }.to raise_error(ArgumentError)
     end
 
     it 'should raise a useful error when nil is returned' do
-      expect { hiera_include.call(scope, 'badkey') }.to raise_error(Puppet::ParseError, /Could not find data item badkey/)
+      expect { func('badkey') }.to raise_error(Puppet::DataBinding::LookupError, /did not find a value for the name 'badkey'/)
     end
 
-    it 'should use the array resolution_type' do
-      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[4]).to be(:array) }.returns(%w[foo bar baz])
-      hiera_include.expects(:call_function).with('include', %w[foo bar baz])
-      hiera_include.call(scope, 'key', {'key' => 'foo_result'})
+    it 'should use the array resolution_type to include classes' do
+      expect(func('fbb').map { |c| c.class_name }).to eql(%w[mod::foo mod::bar mod::baz])
+    end
+
+    it 'should log deprecation errors' do
+      func('fbb')
+      expect(warnings).to include(/The function 'hiera_include' is deprecated in favor of using 'lookup'. See https:/)
     end
 
     it 'should not raise an error if the resulting hiera lookup returns an empty array' do
-      Hiera.any_instance.expects(:lookup).returns []
-      expect { hiera_include.call(scope, 'key') }.to_not raise_error
+      expect { func('empty_array') }.to_not raise_error
     end
 
-    it 'should use default block' do
-      hiera_include.expects(:call_function).with('include', %w[key foo])
-      hiera_include.call(scope, 'foo') { |k| ['key', k] }
+    it 'should use default block array to include classes' do
+      expect(func('foo') { |k| ['mod::bar', "mod::#{k}"] }.map { |c| c.class_name }).to eql(%w[mod::bar mod::foo])
     end
   end
 end

data/spec/unit/functions/include_spec.rb

@@ -0,0 +1,175 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'puppet/parser/functions'
+require 'matchers/containment_matchers'
+require 'matchers/resource'
+require 'matchers/include_in_order'
+require 'unit/functions/shared'
+
+
+describe 'The "include" function' do
+  include PuppetSpec::Compiler
+  include ContainmentMatchers
+  include Matchers::Resource
+
+  before(:each) do
+    compiler  = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
+    @scope = Puppet::Parser::Scope.new(compiler)
+  end
+
+  it "includes a class" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class included {
+        notify { "included": }
+      }
+
+      include included
+    MANIFEST
+
+    expect(catalog.classes).to include("included")
+  end
+
+  it "includes a class when using a fully qualified anchored name" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class included {
+        notify { "included": }
+      }
+
+      include ::included
+    MANIFEST
+
+    expect(catalog.classes).to include("included")
+  end
+
+  it "includes multiple classes" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class included {
+        notify { "included": }
+      }
+      class included_too {
+        notify { "included_too": }
+      }
+
+      include included, included_too
+    MANIFEST
+
+    expect(catalog.classes).to include("included")
+    expect(catalog.classes).to include("included_too")
+  end
+
+  it "includes multiple classes given as an array" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class included {
+        notify { "included": }
+      }
+      class included_too {
+        notify { "included_too": }
+      }
+
+      include [included, included_too]
+    MANIFEST
+
+    expect(catalog.classes).to include("included")
+    expect(catalog.classes).to include("included_too")
+  end
+
+  it "flattens nested arrays" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class included {
+        notify { "included": }
+      }
+      class included_too {
+        notify { "included_too": }
+      }
+
+      include [[[included], [[[included_too]]]]]
+    MANIFEST
+
+    expect(catalog.classes).to include("included")
+    expect(catalog.classes).to include("included_too")
+  end
+
+  it "raises an error if class does not exist" do
+    expect {
+      catalog = compile_to_catalog(<<-MANIFEST)
+        include the_god_in_your_religion
+      MANIFEST
+    }.to raise_error(Puppet::Error)
+  end
+
+  it "does not contained the included class in the current class" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class not_contained {
+        notify { "not_contained": }
+      }
+
+      class container {
+        include not_contained
+      }
+
+      include container
+    MANIFEST
+
+    expect(catalog).to_not contain_class("not_contained").in("container")
+  end
+
+
+  it 'produces an array with a single class references given a single argument' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class a {
+        notify { "a": }
+      }
+
+      $x = include(a)
+      Array[Type[Class], 1, 1].assert_type($x)
+      notify { 'feedback': message => "$x" }
+    MANIFEST
+
+    feedback = catalog.resource("Notify", "feedback")
+    expect(feedback[:message]).to eql("[Class[a]]")
+  end
+
+  it 'produces an array with class references given multiple arguments' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class a {
+        notify { "a": }
+      }
+
+      class b {
+        notify { "b": }
+      }
+
+      $x = include(a, b)
+      Array[Type[Class], 2, 2].assert_type($x)
+      notify { 'feedback': message => "$x" }
+    MANIFEST
+
+    feedback = catalog.resource("Notify", "feedback")
+    expect(feedback[:message]).to eql("[Class[a], Class[b]]")
+  end
+
+  it 'allows the result to be used in a relationship operation' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class a {
+        notify { "a": }
+      }
+
+      class b {
+        notify { "b": }
+      }
+
+      notify { 'c': }
+
+      include(a, b) -> Notify[c]
+    MANIFEST
+
+    # Assert relationships are formed
+    expect(catalog.resource("Class", "a")[:before][0]).to eql('Notify[c]')
+    expect(catalog.resource("Class", "b")[:before][0]).to eql('Notify[c]')
+  end
+
+  it_should_behave_like 'all functions transforming relative to absolute names', :include
+  it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :include
+
+end

data/spec/unit/functions/inline_epp_spec.rb

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

data/spec/unit/functions/lest_spec.rb

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

data/spec/unit/functions/logging_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe 'the log function' do
+  include PuppetSpec::Compiler
+
+  def collect_logs(code)
+    Puppet[:code] = code
+    node = Puppet::Node.new('logtest')
+    compiler = Puppet::Parser::Compiler.new(node)
+    node.environment.check_for_reparse
+    logs = []
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      compiler.compile
+    end
+    logs
+  end
+
+  def expect_log(code, log_level, message)
+    logs = collect_logs(code)
+    expect(logs.size).to eql(1)
+    expect(logs[0].level).to eql(log_level)
+    expect(logs[0].message).to eql(message)
+  end
+
+  before(:each) do
+    Puppet[:log_level] = 'debug'
+  end
+
+  Puppet::Util::Log.levels.each do |level|
+    context "for log level '#{level}'" do
+      it 'can be called' do
+        expect_log("#{level.to_s}('yay')", level, 'yay')
+      end
+
+      it 'joins multiple arguments using space' do
+        # Not using the evaluator would result in yay {"a"=>"b", "c"=>"d"}
+        expect_log("#{level.to_s}('a', 'b', 3)", level, 'a b 3')
+      end
+
+      it 'uses the evaluator to format output' do
+        # Not using the evaluator would result in yay {"a"=>"b", "c"=>"d"}
+        expect_log("#{level.to_s}('yay', {a => b, c => d})", level, 'yay {a => b, c => d}')
+      end
+
+      it 'returns undef value' do
+        logs = collect_logs("notice(type(#{level.to_s}('yay')))")
+        expect(logs.size).to eql(2)
+        expect(logs[1].level).to eql(:notice)
+        expect(logs[1].message).to eql('Undef')
+      end
+    end
+  end
+end