puppet 4.1.0 → 4.10.0

data/spec/unit/functions4_spec.rb

@@ -10,18 +10,24 @@ module FunctionAPISpecModule
 
   class TestFunctionLoader < Puppet::Pops::Loader::StaticLoader
     def initialize
-      @functions = {}
+      @constants = {}
     end
 
     def add_function(name, function)
-      typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, name)
-      entry = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, function, __FILE__)
-      @functions[typed_name] = entry
+      set_entry(Puppet::Pops::Loader::TypedName.new(:function, name), function, __FILE__)
+    end
+
+    def add_type(name, type)
+      set_entry(Puppet::Pops::Loader::TypedName.new(:type, name), type, __FILE__)
+    end
+
+    def set_entry(typed_name, value, origin = nil)
+      @constants[typed_name] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, value, origin)
     end
 
     # override StaticLoader
     def load_constant(typed_name)
-      @functions[typed_name]
+      @constants[typed_name]
     end
   end
 end
@@ -74,11 +80,7 @@ describe 'the 4x function api' do
   it 'an error is raised when calling a no arguments function with arguments' do
     f = create_noargs_function_class()
     func = f.new(:closure_scope, :loader)
-    expect{func.call({}, 'surprise')}.to raise_error(ArgumentError, "function 'test' called with mis-matched arguments
-expected:
-  test() - arg count {0}
-actual:
-  test(String) - arg count {1}")
+    expect{func.call({}, 'surprise')}.to raise_error(ArgumentError, "'test' expects no arguments, got 1")
   end
 
   it 'a simple function can be called' do
@@ -97,11 +99,7 @@ actual:
     signature = 'Any x, Any y'
     expect do
       func.call({}, 10)
-    end.to raise_error(ArgumentError, "function 'min' called with mis-matched arguments
-expected:
-  min(#{signature}) - arg count {2}
-actual:
-  min(Integer) - arg count {1}")
+    end.to raise_error(ArgumentError, "'min' expects 2 arguments, got 1")
   end
 
   it 'an error is raised if called with too many arguments' do
@@ -112,12 +110,14 @@ actual:
     signature = 'Any x, Any y'
     expect do
       func.call({}, 10, 10, 10)
-    end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
-"function 'min' called with mis-matched arguments
-expected:
-  min(#{signature}) - arg count {2}
-actual:
-  min(Integer, Integer, Integer) - arg count {3}")))
+    end.to raise_error(ArgumentError, "'min' expects 2 arguments, got 3")
+  end
+
+  it 'correct dispatch is chosen when zero parameter dispatch exists' do
+    f = create_function_with_no_parameter_dispatch
+    func = f.new(:closure_scope, :loader)
+    expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
+    expect(func.call({}, 1)).to eql(1)
   end
 
   it 'an error is raised if simple function-name and method are not matched' do
@@ -151,44 +151,22 @@ actual:
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
-        func.call({}, 10, 10, 10)
-      end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
-"function 'min' called with mis-matched arguments
-expected:
-  min(Numeric a, Numeric b) - arg count {2}
-actual:
-  min(Integer, Integer, Integer) - arg count {3}")))
-    end
-
-    it 'an error includes optional indicators and count for last element' do
-      f = create_function_with_optionals_and_varargs()
-      # TODO: Bogus parameters, not yet used
-      func = f.new(:closure_scope, :loader)
-      expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
-      signature = 'Any x, Any y, Any a?, Any b?, Any c{0,}'
-      expect do
-        func.call({}, 10)
-      end.to raise_error(ArgumentError,
-"function 'min' called with mis-matched arguments
-expected:
-  min(#{signature}) - arg count {2,}
-actual:
-  min(Integer) - arg count {1}")
+        func.call({}, 10, 'ten')
+      end.to raise_error(ArgumentError, "'min' parameter 'b' expects a Numeric value, got String")
     end
 
-    it 'an error includes optional indicators and count for last element when defined via dispatch' do
-      f = create_function_with_optionals_and_repeated_via_dispatch()
+    it 'an error includes optional indicators for last element' do
+      f = create_function_with_optionals_and_repeated_via_multiple_dispatch()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
-        func.call({}, 10)
-      end.to raise_error(ArgumentError,
-"function 'min' called with mis-matched arguments
-expected:
-  min(Numeric x, Numeric y, Numeric a?, Numeric b?, Numeric c{0,}) - arg count {2,}
-actual:
-  min(Integer) - arg count {1}")
+        func.call({}, 3, 10, 3, "4")
+      end.to raise_error(ArgumentError, "'min' expects one of:
+  (Numeric x, Numeric y, Numeric a?, Numeric b?, Numeric c*)
+    rejected: parameter 'b' expects a Numeric value, got String
+  (String x, String y, String a+)
+    rejected: parameter 'x' expects a String value, got Integer")
     end
 
     it 'can create optional repeated parameter' do
@@ -210,12 +188,7 @@ actual:
       func = f.new(:closure_scope, :loader)
       expect(func.call({}, 1)).to eql(1)
       expect(func.call({}, 1, 2)).to eql(2)
-      expect { func.call({}) }.to raise_error(ArgumentError,
-"function 'count_args' called with mis-matched arguments
-expected:
-  count_args(Any c{1,}) - arg count {1,}
-actual:
-  count_args(Undef{0}) - arg count {0}")
+      expect { func.call({}) }.to raise_error(ArgumentError, "'count_args' expects at least 1 argument, got none")
     end
 
     it 'can create scope_param followed by repeated  parameter' do
@@ -256,14 +229,28 @@ actual:
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
-        func.call({}, 10, 10, 10)
-      end.to raise_error(ArgumentError,
-"function 'min' called with mis-matched arguments
-expected one of:
-  min(Numeric a, Numeric b) - arg count {2}
-  min(String s1, String s2) - arg count {2}
-actual:
-  min(Integer, Integer, Integer) - arg count {3}")
+        func.call({}, 10, '20')
+      end.to raise_error(ArgumentError, "'min' expects one of:
+  (Numeric a, Numeric b)
+    rejected: parameter 'b' expects a Numeric value, got String
+  (String s1, String s2)
+    rejected: parameter 's1' expects a String value, got Integer")
+    end
+
+    context 'an argument_mismatch handler' do
+      let(:func) { create_function_with_mismatch_handler.new(:closure_scope, :loader) }
+
+      it 'is called on matching arguments' do
+        expect { func.call({}, '1') }.to raise_error(ArgumentError, "'test' It's not OK to pass a string")
+      end
+
+      it 'is not called unless arguments are matching' do
+        expect { func.call({}, '1', 3) }.to raise_error(ArgumentError, "'test' expects 1 argument, got 2")
+      end
+
+      it 'is not included in a signature mismatch description' do
+        expect { func.call({}, 2.3) }.to raise_error { |e| expect(e.message).not_to match(/String/) }
+      end
     end
 
     context 'can use injection' do
@@ -334,12 +321,7 @@ actual:
         the_function = create_function_with_required_block_all_defaults().new(:closure_scope, :loader)
         expect do
           the_function.call({}, 10)
-        end.to raise_error(ArgumentError,
-"function 'test' called with mis-matched arguments
-expected:
-  test(Integer x, Callable block) - arg count {2}
-actual:
-  test(Integer) - arg count {1}")
+        end.to raise_error(ArgumentError, "'test' expects a block")
       end
 
       it 'such that, an optional block can be defined and given as an argument' do
@@ -361,7 +343,7 @@ actual:
 
     context 'provides signature information' do
       it 'about capture rest (varargs)' do
-        fc = create_function_with_optionals_and_varargs
+        fc = create_function_with_optionals_and_repeated
         signatures = fc.signatures
         expect(signatures.size).to eql(1)
         signature = signatures[0]
@@ -369,14 +351,14 @@ actual:
       end
 
       it 'about optional and required parameters' do
-        fc = create_function_with_optionals_and_varargs
+        fc = create_function_with_optionals_and_repeated
         signature = fc.signatures[0]
         expect(signature.args_range).to eql( [2, Float::INFINITY ] )
         expect(signature.infinity?(signature.args_range[1])).to be_truthy
       end
 
       it 'about block not being allowed' do
-        fc = create_function_with_optionals_and_varargs
+        fc = create_function_with_optionals_and_repeated
         signature = fc.signatures[0]
         expect(signature.block_range).to eql( [ 0, 0 ] )
         expect(signature.block_type).to be_nil
@@ -467,7 +449,7 @@ actual:
         end
         # initiate the function the same way the loader initiates it
         f = fc.new(:closure_scope, Puppet.lookup(:loaders).puppet_system_loader)
-        expect{f.call({})}.to raise_error(ArgumentError, "Function test(): cannot call function 'no_such_function' - not found")
+        expect{f.call({})}.to raise_error(ArgumentError, "Function test(): Unknown function: 'no_such_function'")
       end
     end
 
@@ -508,13 +490,145 @@ actual:
         # evaluate a puppet call
         source = "testing::test(10) |$x| { $x+1 }"
         program = parser.parse_string(source, __FILE__)
-        Puppet::Pops::Adapters::LoaderAdapter.adapt(program.model).loader = the_loader
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns(the_loader)
         expect(parser.evaluate(scope, program)).to eql(11)
       end
     end
 
+    context 'can use a loader when parsing types in function dispatch, and' do
+      let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
+
+      it 'uses return_type to validate returned value' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            dispatch :test do
+              param 'Integer', :x
+              return_type 'String'
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string('testing::test(10)', __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error,
+          /value returned from function 'test' has wrong type, expects a String value, got Integer/)
+      end
+
+      it 'resolve a referenced Type alias' do
+        the_loader = loader()
+        the_loader.add_type('myalias', type_alias_t('MyAlias', 'Integer'))
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            dispatch :test do
+              param 'MyAlias', :x
+              return_type 'MyAlias'
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string('testing::test(10)', __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect(parser.evaluate({}, program)).to eql(10)
+      end
+
+      it 'reports a reference to an unresolved type' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            dispatch :test do
+              param 'MyAlias', :x
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string('testing::test(10)', __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error, /parameter 'x' references an unresolved type 'MyAlias'/)
+      end
+
+      it 'create local Type aliases' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            local_types do
+              type 'MyType = Array[Integer]'
+            end
+            dispatch :test do
+              param 'MyType', :x
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string('testing::test([10,20])', __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect(parser.evaluate({}, program)).to eq([10,20])
+      end
+
+      it 'create nested local Type aliases' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            local_types do
+              type 'InnerType = Array[Integer]'
+              type 'OuterType = Hash[String,InnerType]'
+            end
+            dispatch :test do
+              param 'OuterType', :x
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string("testing::test({'x' => [10,20]})", __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect(parser.evaluate({}, program)).to eq({'x' => [10,20]})
+      end
+
+      it 'create self referencing local Type aliases' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            local_types do
+              type 'Tree = Hash[String,Variant[String,Tree]]'
+            end
+            dispatch :test do
+              param 'Tree', :x
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string("testing::test({'x' => {'y' => 'n'}})", __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
+        expect(parser.evaluate({}, program)).to eq({'x' => {'y' => 'n'}})
+      end
+    end
   end
 
+
   def create_noargs_function_class
     f = Puppet::Functions.create_function('test') do
       def test()
@@ -582,7 +696,7 @@ actual:
     end
   end
 
-  def create_function_with_optionals_and_varargs
+  def create_function_with_optionals_and_repeated
     f = Puppet::Functions.create_function('min') do
       def min(x,y,a=1, b=1, *c)
         x <= y ? x : y
@@ -605,6 +719,39 @@ actual:
     end
   end
 
+  def create_function_with_optionals_and_repeated_via_multiple_dispatch
+    f = Puppet::Functions.create_function('min') do
+      dispatch :min do
+        param 'Numeric', :x
+        param 'Numeric', :y
+        optional_param 'Numeric', :a
+        optional_param 'Numeric', :b
+        repeated_param 'Numeric', :c
+      end
+      dispatch :min do
+        param 'String', :x
+        param 'String', :y
+        required_repeated_param 'String', :a
+      end
+      def min(x,y,a=1, b=1, *c)
+        x <= y ? x : y
+      end
+    end
+  end
+
+  def create_function_with_required_repeated_via_dispatch
+    f = Puppet::Functions.create_function('min') do
+      dispatch :min do
+        param 'Numeric', :x
+        param 'Numeric', :y
+        required_repeated_param 'Numeric', :z
+      end
+      def min(x,y, *z)
+        x <= y ? x : y
+      end
+    end
+  end
+
   def create_function_with_repeated
     f = Puppet::Functions.create_function('count_args') do
       dispatch :count_args do
@@ -815,4 +962,48 @@ actual:
     end
   end
 
+  def create_function_with_no_parameter_dispatch
+    f = Puppet::Functions.create_function('test') do
+      dispatch :test_no_args do
+      end
+      dispatch :test_one_arg do
+        param 'Integer', :x
+      end
+      def test_no_args
+        0
+      end
+      def test_one_arg(x)
+        x
+      end
+    end
+  end
+
+  def create_function_with_mismatch_handler
+    f = Puppet::Functions.create_function('test') do
+      dispatch :test do
+        param 'Integer', :x
+      end
+
+      argument_mismatch :on_error do
+        param 'String', :x
+      end
+
+      def test(x)
+        yield(5,x) if block_given?
+      end
+
+      def on_error(x)
+        "It's not OK to pass a string"
+      end
+    end
+  end
+
+  def type_alias_t(name, type_string)
+    type_expr = Puppet::Pops::Parser::EvaluatingParser.new.parse_string(type_string).current
+    Puppet::Pops::Types::TypeFactory.type_alias(name, type_expr)
+  end
+
+  def get_binding(loader_injected_arg)
+    binding
+  end
 end

data/spec/unit/graph/rb_tree_map_spec.rb

@@ -376,7 +376,7 @@ describe Puppet::Graph::RbTreeMap do
   describe "#each" do
     it "should yield each pair in the tree in order if a block is provided" do
       # Insert in reverse to demonstrate they aren't being yielded in insertion order
-      (1..5).to_a.reverse.each {|i| subject[i] = i.to_s}
+      (1..5).to_a.reverse_each {|i| subject[i] = i.to_s}
 
       nodes = []
       subject.each do |key,value|

data/spec/unit/graph/sequential_prioritizer_spec.rb

@@ -27,6 +27,6 @@ describe Puppet::Graph::SequentialPrioritizer do
   it "fails to prioritize a key contained in an unknown container" do
     expect do
       priorities.generate_priority_contained_in("unknown", "child 1")
-    end.to raise_error
+    end.to raise_error(NoMethodError, /`down' for nil/)
   end
 end

data/spec/unit/graph/simple_graph_spec.rb

@@ -430,7 +430,7 @@ describe Puppet::Graph::SimpleGraph do
     end
 
     it "should write a dot file based on the passed name" do
-      File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil))
+      File.expects(:open).with(@file, "w:UTF-8").yields(stub("file", :puts => nil))
       @graph.expects(:to_dot).with("name" => @name.to_s.capitalize)
       Puppet[:graph] = true
       @graph.write_graph(@name)

data/spec/unit/hiera/scope_spec.rb

@@ -74,11 +74,14 @@ describe Hiera::Scope do
     end
   end
 
-  describe "#include?" do
+  describe "#exist?" do
     it "should correctly report missing data" do
-      real["foo"] = ""
+      real["nil_value"] = nil
+      real["blank_value"] = ""
 
-      expect(scope.include?("foo")).to eq(false)
+      expect(scope.exist?("nil_value")).to eq(true)
+      expect(scope.exist?("blank_value")).to eq(true)
+      expect(scope.exist?("missing_value")).to eq(false)
     end
 
     it "should always return true for calling_class and calling_module" do

data/spec/unit/hiera_puppet_spec.rb

@@ -63,17 +63,58 @@ describe 'HieraPuppet' do
       expect(HieraPuppet.send(:hiera_config_file)).to eq(Puppet[:hiera_config])
     end
 
-    it "should use Puppet.settings[:codedir] as the base directory when hiera_config is not set" do
-      begin
+    context 'when hiera_config is not set' do
+      let(:code_hiera_config) { File.join(Puppet[:codedir], 'hiera.yaml') }
+      let(:conf_hiera_config) { File.join(Puppet[:confdir], 'hiera.yaml') }
+
+      before(:each) do
+        Puppet.settings.setting(:hiera_config).send(:remove_instance_variable, :@evaluated_default)
         Puppet.settings[:hiera_config] = nil
-      rescue ArgumentError => detail
-        raise unless detail.message =~ /unknown setting/
+        Puppet.settings[:codedir] = '/dev/null/puppetlabs/code'
+        Puppet.settings[:confdir] = '/dev/null/puppetlabs/puppet'
       end
-      Puppet.settings[:codedir] = "/dev/null/puppet"
-      hiera_config = File.join(Puppet[:codedir], 'hiera.yaml')
-      Puppet::FileSystem.stubs(:exist?).with(hiera_config).returns(true)
 
-      expect(HieraPuppet.send(:hiera_config_file)).to eq(hiera_config)
+      it "should use Puppet.settings[:codedir]/hiera.yaml when '$codedir/hiera.yaml' exists and '$confdir/hiera.yaml' does not exist" do
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(false)
+
+        expect(HieraPuppet.send(:hiera_config_file)).to eq(code_hiera_config)
+      end
+
+      it "should use Puppet.settings[:confdir]/hiera.yaml when '$codedir/hiera.yaml' does not exist and '$confdir/hiera.yaml' exists" do
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(false)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
+
+        expect(HieraPuppet.send(:hiera_config_file)).to eq(conf_hiera_config)
+      end
+
+      it "should use Puppet.settings[:codedir]/hiera.yaml when '$codedir/hiera.yaml' exists and '$confdir/hiera.yaml' exists" do
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
+
+        expect(HieraPuppet.send(:hiera_config_file)).to eq(code_hiera_config)
+      end
+
+      it "should return nil when neither '$codedir/hiera.yaml' nor '$confdir/hiera.yaml' exists" do
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(false)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(false)
+
+        expect(HieraPuppet.send(:hiera_config_file)).to eq(nil)
+      end
+
+      it "should return explicitly set option even if both '$codedir/hiera.yaml' and '$confdir/hiera.yaml' exists" do
+        if Puppet::Util::Platform.windows?
+          explicit_hiera_config = 'C:/an/explicit/hiera.yaml'
+        else
+          explicit_hiera_config = '/an/explicit/hiera.yaml'
+        end
+        Puppet.settings[:hiera_config] = explicit_hiera_config
+        Puppet::FileSystem.stubs(:exist?).with(explicit_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
+
+        expect(HieraPuppet.send(:hiera_config_file)).to eq(explicit_hiera_config)
+      end
     end
   end