puppet 3.7.4 → 3.7.5

data/spec/unit/daemon_spec.rb

@@ -55,8 +55,6 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
 
         Puppet.expects(:notice)
 
-        daemon.expects(method)
-
         daemon.set_signal_traps
       end
     end

data/spec/unit/environments_spec.rb

@@ -489,7 +489,7 @@ config_version=$vardir/random/scripts
         env = Puppet::Node::Environment.create(:cached, [])
         mocked_loader = mock('loader')
         mocked_loader.expects(:get).with(:cached).returns(env).once
-        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
+        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env,'current', 20)).once
 
         cached = Puppet::Environments::Cached.new(mocked_loader)
 
@@ -515,7 +515,7 @@ config_version=$vardir/random/scripts
         env = Puppet::Node::Environment.create(:cached, [])
         mocked_loader = mock('loader')
         mocked_loader.expects(:get).with(:cached).returns(env).once
-        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
+        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env,'current', 20)).once
 
         cached = Puppet::Environments::Cached.new(mocked_loader)
 

data/spec/unit/functions/assert_type_spec.rb

@@ -3,19 +3,10 @@ require 'puppet/pops'
 require 'puppet/loaders'
 
 describe 'the assert_type function' do
-
   after(:all) { Puppet::Pops::Loaders.clear }
 
-  around(:each) do |example|
-    loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
-    Puppet.override({:loaders => loaders}, "test-example") do
-      example.run
-    end
-  end
-
-  let(:func) do
-    Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'assert_type')
-  end
+  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
+  let(:func) { loaders.puppet_system_loader.load(:function, 'assert_type') }
 
   it 'asserts compliant type by returning the value' do
     expect(func.call({}, type(String), 'hello world')).to eql('hello world')
@@ -50,9 +41,10 @@ actual:
   end
 
   it 'can be called with a callable that receives a specific type' do
-    expected, actual = func.call({}, optional(String), 1, create_callable_2_args_unit)
+    expected, actual, actual2 = func.call({}, 'Optional[String]', 1) { |expected, actual| [expected, actual, actual] }
     expect(expected.to_s).to eql('Optional[String]')
     expect(actual.to_s).to eql('Integer[1, 1]')
+    expect(actual2.to_s).to eql('Integer[1, 1]')
   end
 
   def optional(type_ref)
@@ -62,17 +54,4 @@ actual:
   def type(type_ref)
     Puppet::Pops::Types::TypeFactory.type_of(type_ref)
   end
-
-  def create_callable_2_args_unit()
-    Puppet::Functions.create_function(:func) do
-      dispatch :func do
-        param 'Type', 'expected'
-        param 'Type', 'actual'
-      end
-
-      def func(expected, actual)
-        [expected, actual]
-      end
-    end.new({}, nil)
-  end
 end

data/spec/unit/functions/hiera_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+require 'puppet_spec/scope'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'when calling' do
+  include PuppetSpec::Scope
+
+  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 }
+
+  context 'hiera' do
+    let(:hiera) { loader.load(:function, 'hiera') }
+
+    it 'should require a key argument' do
+      expect { hiera.call(scope, []) }.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/)
+    end
+
+    it 'should use the priority resolution_type' do
+      Hiera.any_instance.expects(:lookup).with { |*args| args[4].should be(:priority) }.returns('foo_result')
+      expect(hiera.call(scope, 'key')).to eql('foo_result')
+    end
+
+    it 'should propagate optional default' do
+      dflt = 'the_default'
+      Hiera.any_instance.expects(:lookup).with { |*args| args[1].should be(dflt) }.returns('foo_result')
+      expect(hiera.call(scope, 'key', dflt)).to eql('foo_result')
+    end
+
+    it 'should propagate optional override' do
+      ovr = 'the_override'
+      Hiera.any_instance.expects(:lookup).with { |*args| args[3].should be(ovr) }.returns('foo_result')
+      expect(hiera.call(scope, 'key', nil, ovr)).to eql('foo_result')
+    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'")
+    end
+
+    # Test disabled since it assumes that Yaml_backend returns nil when a key is not found and that this
+    # triggers use of default. This changes in Hiera 2.0 so that the backend throws a :no_such_key exception.
+    # Changing that here will invalidate tests using hiera stable.
+    #
+    # it 'should propagate optional override when combined with default block' do
+    #   ovr = 'the_override'
+    #   Hiera::Backend::Yaml_backend.any_instance.expects(:lookup).with { |*args| args[2].should be(ovr) }
+    #   expect(hiera.call(scope, 'foo', ovr) { |k| "default for key '#{k}'" }).to eql("default for key 'foo'")
+    # end
+  end
+
+  context 'hiera_array' do
+    # noinspection RubyResolve
+    let(:hiera_array) { loader.load(:function, 'hiera_array') }
+
+    it 'should require a key argument' do
+      expect { hiera_array.call(scope, []) }.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/)
+    end
+
+    it 'should use the array resolution_type' do
+      Hiera.any_instance.expects(:lookup).with { |*args| args[4].should be(:array) }.returns(%w[foo bar baz])
+      expect(hiera_array.call(scope, 'key', {'key' => 'foo_result'})).to eql(%w[foo bar baz])
+    end
+
+    it 'should use default block' do
+      expect(hiera_array.call(scope, 'foo') { |k| ['key', k] }).to eql(%w[key foo])
+    end
+  end
+
+  context 'hiera_hash' do
+    let(:hiera_hash) { loader.load(:function, 'hiera_hash') }
+
+    it 'should require a key argument' do
+      expect { hiera_hash.call(scope, []) }.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/)
+    end
+
+    it 'should use the hash resolution_type' do
+      Hiera.any_instance.expects(:lookup).with { |*args| args[4].should be(:hash) }.returns({'foo' => 'result'})
+      expect(hiera_hash.call(scope, 'key', {'key' => 'foo_result'})).to eql({'foo' => 'result'})
+    end
+
+    it 'should use default block' do
+      expect(hiera_hash.call(scope, 'foo') { |k| {'key' => k} }).to eql({'key' => 'foo'})
+    end
+  end
+
+  context 'hiera_include' do
+    let(:hiera_include) { loader.load(:function, 'hiera_include') }
+
+    it 'should require a key argument' do
+      expect { hiera_include.call(scope, []) }.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/)
+    end
+
+    it 'should use the array resolution_type' do
+      Hiera.any_instance.expects(:lookup).with { |*args| args[4].should 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'})
+    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
+    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] }
+    end
+  end
+end

data/spec/unit/functions/with_spec.rb

@@ -27,9 +27,14 @@ describe 'the with function' do
     expect(compile_to_catalog('notify { test: message => "data" } with(Notify[test]) |$x| { notify { "${x[message]}": } }')).to have_resource('Notify[data]')
   end
 
-  it 'errors when not given enough arguments for the lambda' do
-    expect do
-      compile_to_catalog('with(1) |$x, $y| { }')
-    end.to raise_error(/Parameter \$y is required but no value was given/m)
+  # Conditinoally left out for Ruby 1.8.x since the Proc created for the expected number of arguments will accept
+  # a call with fewer arguments and then pass all arguments to the closure. The closure then receives an argument
+  # array of correct size with nil values instead of an array with too few arguments
+  unless RUBY_VERSION[0,3] == '1.8'
+    it 'errors when not given enough arguments for the lambda' do
+      expect do
+        compile_to_catalog('with(1) |$x, $y| { }')
+      end.to raise_error(/Parameter \$y is required but no value was given/m)
+    end
   end
 end

data/spec/unit/functions4_spec.rb

@@ -191,6 +191,13 @@ actual:
   min(Integer) - arg count {1}")
     end
 
+    it 'a function can use inexact argument mapping' do
+      f = create_function_with_inexact_dispatch
+      func = f.new(:closure_scope, :loader)
+      expect(func.call({}, 3,4,5)).to eql([Fixnum, Fixnum, Fixnum])
+      expect(func.call({}, 'Apple', 'Banana')).to eql([String, String])
+    end
+
     it 'a function can be created using dispatch and called' do
       f = create_min_function_class_disptaching_to_two_methods()
       func = f.new(:closure_scope, :loader)
@@ -198,6 +205,14 @@ actual:
       expect(func.call({}, 'Apple', 'Banana')).to eql('Apple')
     end
 
+    it 'a function can not be created with parameters declared after a repeated parameter' do
+      expect { create_function_with_param_after_repeated }.to raise_error(ArgumentError, 'Parameters cannot be added after a repeated parameter')
+    end
+
+    it 'a function can not be created with required parameters declared after optional ones' do
+      expect { create_function_with_rq_after_opt }.to raise_error(ArgumentError, 'A required parameter cannot be added after an optional parameter')
+    end
+
     it 'an error is raised with reference to multiple methods when called with mis-matched arguments' do
       f = create_min_function_class_disptaching_to_two_methods()
       # TODO: Bogus parameters, not yet used
@@ -273,15 +288,12 @@ actual:
 
     context 'supports lambdas' do
       it 'such that, a required block can be defined and given as an argument' do
-        # use a Function as callable
-        the_callable = create_min_function_class().new(:closure_scope, :loader)
         the_function = create_function_with_required_block_all_defaults().new(:closure_scope, :loader)
-        result = the_function.call({}, 10, the_callable)
-        expect(result).to be(the_callable)
+        result = the_function.call({}, 7) { |a,b| a < b ? a : b }
+        expect(result).to eq(7)
       end
 
       it 'such that, a missing required block when called raises an error' do
-        # use a Function as callable
         the_function = create_function_with_required_block_all_defaults().new(:closure_scope, :loader)
         expect do
           the_function.call({}, 10)
@@ -294,17 +306,19 @@ actual:
       end
 
       it 'such that, an optional block can be defined and given as an argument' do
-        # use a Function as callable
-        the_callable = create_min_function_class().new(:closure_scope, :loader)
         the_function = create_function_with_optional_block_all_defaults().new(:closure_scope, :loader)
-        result = the_function.call({}, 10, the_callable)
-        expect(result).to be(the_callable)
+        result = the_function.call({}, 4) { |a,b| a < b ? a : b }
+        expect(result).to eql(4)
       end
 
       it 'such that, an optional block can be omitted when called and gets the value nil' do
-        # use a Function as callable
         the_function = create_function_with_optional_block_all_defaults().new(:closure_scope, :loader)
-        expect(the_function.call({}, 10)).to be_nil
+        expect(the_function.call({}, 2)).to be_nil
+      end
+
+      it 'such that, a scope can be injected and a block can be used' do
+        the_function = create_function_with_scope_required_block_all_defaults().new(:closure_scope, :loader)
+        expect(the_function.call({}, 1) { |a,b| a < b ? a : b }).to eql(1)
       end
     end
 
@@ -455,9 +469,9 @@ actual:
             # block called 'the_block', and using "all_callables"
             required_block_param #(all_callables(), 'the_block')
           end
-          def test(x, block)
+          def test(x)
             # call the block with x
-            block.call(closure_scope, x)
+            yield(x)
           end
         end
         # add the function to the loader (as if it had been loaded from somewhere)
@@ -552,12 +566,11 @@ actual:
   def create_function_with_optionals_and_varargs_via_dispatch
     f = Puppet::Functions.create_function('min') do
       dispatch :min do
-        param 'Numeric', 'x'
-        param 'Numeric', 'y'
-        param 'Numeric', 'a'
-        param 'Numeric', 'b'
-        param 'Numeric', 'c'
-        arg_count 2, :default
+        param 'Numeric', :x
+        param 'Numeric', :y
+        optional_param 'Numeric', :a
+        optional_param 'Numeric', :b
+        repeated_param 'Numeric', :c
       end
       def min(x,y,a=1, b=1, *c)
         x <= y ? x : y
@@ -565,6 +578,48 @@ actual:
     end
   end
 
+  def create_function_with_inexact_dispatch
+    f = Puppet::Functions.create_function('t1') do
+      dispatch :t1 do
+        param 'Numeric', :x
+        param 'Numeric', :y
+        repeated_param 'Numeric', :z
+      end
+      dispatch :t1 do
+        param 'String', :x
+        param 'String', :y
+        repeated_param 'String', :z
+      end
+      def t1(first, *x)
+        [first.class, *x.map {|e|e.class}]
+      end
+    end
+  end
+
+  def create_function_with_rq_after_opt
+    f = Puppet::Functions.create_function('t1') do
+      dispatch :t1 do
+        optional_param 'Numeric', :x
+        param 'Numeric', :y
+      end
+      def t1(*x)
+        x
+      end
+    end
+  end
+
+  def create_function_with_param_after_repeated
+    f = Puppet::Functions.create_function('t1') do
+      dispatch :t1 do
+        repeated_param 'Numeric', :x
+        param 'Numeric', :y
+      end
+      def t1(*x)
+        x
+      end
+    end
+  end
+
   def create_function_with_class_injection
     f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
       attr_injected Puppet::Pops::Types::TypeFactory.type_of(FunctionAPISpecModule::TestDuck), :test_attr
@@ -600,13 +655,26 @@ actual:
   def create_function_with_required_block_all_defaults
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
+        param 'Integer', 'x'
+        # use defaults, any callable, name is 'block'
+        block_param
+      end
+      def test(x)
+        yield(8,x)
+      end
+    end
+  end
+
+  def create_function_with_scope_required_block_all_defaults
+    f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
+      dispatch :test do
+        scope_param
         param 'Integer', 'x'
         # use defaults, any callable, name is 'block'
         required_block_param
       end
-      def test(x, block)
-        # returns the block to make it easy to test what it got when called
-        block
+      def test(scope, x)
+        yield(3,x)
       end
     end
   end
@@ -618,9 +686,8 @@ actual:
         # use defaults, any callable, name is 'block'
         required_block_param 'the_block'
       end
-      def test(x, block)
-        # returns the block to make it easy to test what it got when called
-        block
+      def test(x)
+        yield
       end
     end
   end
@@ -631,9 +698,8 @@ actual:
         param 'Integer', 'x'
         required_block_param
       end
-      def test(x, block)
-        # returns the block to make it easy to test what it got when called
-        block
+      def test(x)
+        yield
       end
     end
   end
@@ -645,9 +711,8 @@ actual:
         # use defaults, any callable, name is 'block'
         required_block_param('Callable', 'the_block')
       end
-      def test(x, block)
-        # returns the block to make it easy to test what it got when called
-        block
+      def test(x)
+        yield
       end
     end
   end
@@ -659,10 +724,8 @@ actual:
         # use defaults, any callable, name is 'block'
         optional_block_param
       end
-      def test(x, block=nil)
-        # returns the block to make it easy to test what it got when called
-        # a default of nil must be used or the call will fail with a missing parameter
-        block
+      def test(x)
+        yield(5,x) if block_given?
       end
     end
   end