puppet 4.0.0 → 5.0.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,50 +151,56 @@ 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}")))
+        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' do
-      f = create_function_with_optionals_and_varargs()
+    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
-      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({}, 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 'an error includes optional indicators and count for last element when defined via dispatch' do
-      f = create_function_with_optionals_and_varargs_via_dispatch()
-      # TODO: Bogus parameters, not yet used
+    it 'can create optional repeated parameter' do
+      f = create_function_with_repeated
       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}")
+      expect(func.call({})).to eql(0)
+      expect(func.call({}, 1)).to eql(1)
+      expect(func.call({}, 1, 2)).to eql(2)
+
+      f = create_function_with_optional_repeated
+      func = f.new(:closure_scope, :loader)
+      expect(func.call({})).to eql(0)
+      expect(func.call({}, 1)).to eql(1)
+      expect(func.call({}, 1, 2)).to eql(2)
+    end
+
+    it 'can create required repeated parameter' do
+      f = create_function_with_required_repeated
+      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, "'count_args' expects at least 1 argument, got none")
+    end
+
+    it 'can create scope_param followed by repeated  parameter' do
+      f = create_function_with_scope_param_required_repeat
+      func = f.new(:closure_scope, :loader)
+      expect(func.call({}, 'yay', 1,2,3)).to eql([{}, 'yay',1,2,3])
     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({}, 3.0,4.0,5.0)).to eql([Float, Float, Float])
       expect(func.call({}, 'Apple', 'Banana')).to eql([String, String])
     end
 
@@ -213,48 +219,37 @@ actual:
       expect { create_function_with_rq_after_opt }.to raise_error(ArgumentError, 'A required parameter cannot be added after an optional parameter')
     end
 
+    it 'a function can not be created with required repeated parameters declared after optional ones' do
+      expect { create_function_with_rq_repeated_after_opt }.to raise_error(ArgumentError, 'A required repeated 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
       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}")
-    end
-
-    context 'can use injection' do
-      before :all do
-        injector = Puppet::Pops::Binder::Injector.create('test') do
-          bind.name('a_string').to('evoe')
-          bind.name('an_int').to(42)
-        end
-        Puppet.push_context({:injector => injector}, "injector for testing function API")
-      end
+        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
 
-      after :all do
-        Puppet.pop_context()
+    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 'attributes can be injected' do
-        f1 = create_function_with_class_injection()
-        f = f1.new(:closure_scope, :loader)
-        expect(f.test_attr2()).to eql("evoe")
-        expect(f.serial().produce(nil)).to eql(42)
-        expect(f.test_attr().class.name).to eql("FunctionAPISpecModule::TestDuck")
+      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 'parameters can be injected and woven with regular dispatch' do
-        f1 = create_function_with_param_injection_regular()
-        f = f1.new(:closure_scope, :loader)
-        expect(f.call(nil, 10, 20)).to eql("evoe! 10, and 20 < 42 = true")
-        expect(f.call(nil, 50, 20)).to eql("evoe! 50, and 20 < 42 = false")
+      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
 
@@ -297,12 +292,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
@@ -324,7 +314,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]
@@ -332,14 +322,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
@@ -430,7 +420,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
 
@@ -471,13 +461,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()
@@ -545,15 +667,30 @@ 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
+      end
+    end
+  end
+
+  def create_function_with_optionals_and_repeated_via_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
       def min(x,y,a=1, b=1, *c)
         x <= y ? x : y
       end
     end
   end
 
-  def create_function_with_optionals_and_varargs_via_dispatch
+  def create_function_with_optionals_and_repeated_via_multiple_dispatch
     f = Puppet::Functions.create_function('min') do
       dispatch :min do
         param 'Numeric', :x
@@ -562,12 +699,63 @@ actual:
         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
+        repeated_param 'Any', :c
+      end
+      def count_args(*c)
+        c.size
+      end
+    end
+  end
+
+  def create_function_with_optional_repeated
+    f = Puppet::Functions.create_function('count_args') do
+      dispatch :count_args do
+        optional_repeated_param 'Any', :c
+      end
+      def count_args(*c)
+        c.size
+      end
+    end
+  end
+
+  def create_function_with_required_repeated
+    f = Puppet::Functions.create_function('count_args') do
+      dispatch :count_args do
+        required_repeated_param 'Any', :c
+      end
+      def count_args(*c)
+        c.size
+      end
+    end
+  end
+
   def create_function_with_inexact_dispatch
     f = Puppet::Functions.create_function('t1') do
       dispatch :t1 do
@@ -598,26 +786,26 @@ actual:
     end
   end
 
-  def create_function_with_param_after_repeated
+  def create_function_with_rq_repeated_after_opt
     f = Puppet::Functions.create_function('t1') do
       dispatch :t1 do
-        repeated_param 'Numeric', :x
-        param 'Numeric', :y
+        optional_param 'Numeric', :x
+        required_repeated_param 'Numeric', :y
       end
-      def t1(*x)
+      def t1(x, *y)
         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
-      attr_injected Puppet::Pops::Types::TypeFactory.string(), :test_attr2, "a_string"
-      attr_injected_producer Puppet::Pops::Types::TypeFactory.integer(), :serial, "an_int"
-
-      def test(x,y,a=1, b=1, *c)
-        x <= y ? x : y
+  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
@@ -682,6 +870,19 @@ actual:
     end
   end
 
+  def create_function_with_scope_param_required_repeat
+    f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
+      dispatch :test do
+        scope_param
+        param 'Any', :extra
+        repeated_param 'Any', :the_block
+      end
+      def test(scope, *args)
+        [scope, *args]
+      end
+    end
+  end
+
   def create_function_with_required_block_given_type
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
@@ -720,4 +921,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)
+    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