puppet 3.7.5-x64-mingw32 → 3.8.1-x64-mingw32

data/spec/unit/functions/defined_spec.rb

@@ -0,0 +1,291 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe "the 'defined' function" do
+  after(:all) { Puppet::Pops::Loaders.clear }
+
+  # This loads the function once and makes it easy to call it
+  # It does not matter that it is not bound to the env used later since the function
+  # looks up everything via the scope that is given to it.
+  # The individual tests needs to have a fresh env/catalog set up
+  #
+  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
+  let(:func) { loaders.puppet_system_loader.load(:function, 'defined') }
+
+  before :each do
+    # This is only for the 4.x version of the defined function
+    Puppet[:parser] = 'future'
+    # A fresh environment is needed for each test since tests creates types and resources
+    environment = Puppet::Node::Environment.create(:testing, [])
+    @node = Puppet::Node.new('yaynode', :environment => environment)
+    @known_resource_types = environment.known_resource_types
+    @compiler = Puppet::Parser::Compiler.new(@node)
+    @scope = Puppet::Parser::Scope.new(@compiler)
+  end
+
+  def newclass(name)
+    @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
+  end
+
+  def newdefine(name)
+    @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
+  end
+
+  def newresource(type, title)
+    resource = Puppet::Resource.new(type, title)
+    @compiler.add_resource(@scope, resource)
+    resource
+  end
+
+  #--- CLASS
+  #
+  context 'can determine if a class' do
+    context 'is defined' do
+
+      it 'by using the class name in string form' do
+        newclass 'yayness'
+        expect(func.call(@scope, 'yayness')).to be_true
+      end
+
+      it 'by using a Type[Class[name]] type reference' do
+        name = 'yayness'
+        newclass name
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(class_type)
+        expect(func.call(@scope, type_type)).to be_true
+      end
+    end
+
+    context 'is not defined' do
+      it 'by using the class name in string form' do
+        expect(func.call(@scope, 'yayness')).to be_false
+      end
+
+      it 'even if there is a define, by using a Type[Class[name]] type reference' do
+        name = 'yayness'
+        newdefine name
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(class_type)
+        expect(func.call(@scope, type_type)).to be_false
+      end
+    end
+
+    context 'is defined and realized' do
+      it 'by using a Class[name] reference' do
+        name = 'cowabunga'
+        newclass name
+        newresource(:class, name)
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        expect(func.call(@scope, class_type)).to be_true
+      end
+    end
+
+    context 'is not realized' do
+      it '(although defined) by using a Class[name] reference' do
+        name = 'cowabunga'
+        newclass name
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        expect(func.call(@scope, class_type)).to be_false
+      end
+
+      it '(and not defined) by using a Class[name] reference' do
+        name = 'cowabunga'
+        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
+        expect(func.call(@scope, class_type)).to be_false
+      end
+    end
+  end
+
+  #---RESOURCE TYPE
+  #
+  context 'can determine if a resource type' do
+    context 'is defined' do
+
+      it 'by using the type name (of a built in type) in string form' do
+        expect(func.call(@scope, 'file')).to be_true
+      end
+
+      it 'by using the type name (of a resource type) in string form' do
+        newdefine 'yayness'
+        expect(func.call(@scope, 'yayness')).to be_true
+      end
+
+      it 'by using a File type reference (built in type)' do
+        resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_true
+      end
+
+      it 'by using a Type[File] type reference' do
+        resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_true
+      end
+
+      it 'by using a Resource[T] type reference (defined type)' do
+        name = 'yayness'
+        newdefine name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
+        expect(func.call(@scope, resource_type)).to be_true
+      end
+
+      it 'by using a Type[Resource[T]] type reference (defined type)' do
+        name = 'yayness'
+        newdefine name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_true
+      end
+    end
+
+    context 'is not defined' do
+      it 'by using the resource name in string form' do
+        expect(func.call(@scope, 'notatype')).to be_false
+      end
+
+      it 'even if there is a class with the same name, by using a Type[Resource[T]] type reference' do
+        name = 'yayness'
+        newclass name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_false
+      end
+    end
+
+    context 'is defined and instance realized' do
+      it 'by using a Resource[T, title] reference for a built in type' do
+        type_name = 'file'
+        title = '/tmp/myfile'
+        newdefine type_name
+        newresource(type_name, title)
+        class_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, class_type)).to be_true
+      end
+
+      it 'by using a Resource[T, title] reference for a defined type' do
+        type_name = 'meme'
+        title = 'cowabunga'
+        newdefine type_name
+        newresource(type_name, title)
+        class_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, class_type)).to be_true
+      end
+    end
+
+    context 'is not realized' do
+      it '(although defined) by using a Resource[T, title] reference or Type[Resource[T, title]] reference' do
+        type_name = 'meme'
+        title = 'cowabunga'
+        newdefine type_name
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, resource_type)).to be_false
+
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_false
+      end
+
+      it '(and not defined) by using a Resource[T, title] reference or Type[Resource[T, title]] reference' do
+        type_name = 'meme'
+        title = 'cowabunga'
+        resource_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
+        expect(func.call(@scope, resource_type)).to be_false
+
+        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
+        expect(func.call(@scope, type_type)).to be_false
+      end
+    end
+  end
+
+  #---VARIABLES
+  #
+  context 'can determine if a variable' do
+    context 'is defined' do
+      it 'by giving the variable in string form' do
+        @scope['x'] = 'something'
+        expect(func.call(@scope, '$x')).to be_true
+      end
+
+      it 'by giving a :: prefixed variable in string form' do
+        @compiler.topscope['x'] = 'something'
+        expect(func.call(@scope, '$::x')).to be_true
+      end
+
+      it 'by giving a numeric variable in string form (when there is a match scope)' do
+        # with no match scope, there are no numeric variables defined
+        expect(func.call(@scope, '$0')).to be_false
+        expect(func.call(@scope, '$42')).to be_false
+        pattern = Regexp.new('.*')
+        @scope.new_match_scope(pattern.match('anything'))
+
+        # with a match scope, all numeric variables are set (the match defines if they have a value or not, but they are defined)
+        # even if their value is undef.
+        expect(func.call(@scope, '$0')).to be_true
+        expect(func.call(@scope, '$42')).to be_true
+      end
+    end
+
+    context 'is undefined' do
+      it 'by giving a :: prefixed or regular variable in string form' do
+        expect(func.call(@scope, '$x')).to be_false
+        expect(func.call(@scope, '$::x')).to be_false
+      end
+    end
+  end
+
+  context 'has any? semantics when given multiple arguments' do
+    it 'and one of the names is a defined user defined type' do
+      newdefine 'yayness'
+      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_true
+    end
+
+    it 'and one of the names is a built type' do
+      expect(func.call(@scope, 'meh', 'file', 'booness')).to be_true
+    end
+
+    it 'and one of the names is a defined class' do
+      newclass 'yayness'
+      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_true
+    end
+
+    it 'is true when at least one variable exists in scope' do
+      @scope['x'] = 'something'
+      expect(func.call(@scope, '$y', '$x', '$z')).to be_true
+    end
+
+    it 'is false when none of the names are defined' do
+      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_false
+    end
+  end
+
+  it 'raises an argument error when asking if Resource type is defined' do
+    resource_type = Puppet::Pops::Types::TypeFactory.resource
+    expect { func.call(@scope, resource_type)}.to raise_error(ArgumentError, /reference to all.*type/)
+  end
+
+  it 'raises an argument error if you ask if Class is defined' do
+    class_type = Puppet::Pops::Types::TypeFactory.host_class
+    expect { func.call(@scope, class_type) }.to raise_error(ArgumentError, /reference to all.*class/)
+  end
+
+  it 'raises error if referencing undef' do
+    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /mis-matched arguments/)
+  end
+
+  it 'raises error if referencing a number' do
+    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /mis-matched arguments/)
+  end
+
+  it 'is false if referencing empty string' do
+    expect(func.call(@scope, '')).to be_false
+  end
+
+  it "is true if referencing 'main'" do
+    # mimic what compiler does with "main" in intial import
+    newclass ''
+    newresource :class, ''
+    expect(func.call(@scope, 'main')).to be_true
+  end
+
+end

data/spec/unit/functions/hiera_spec.rb

@@ -26,18 +26,20 @@ describe 'when calling' do
       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 return default value nil when key is not found' do
+       expect(hiera.call(scope, 'foo', nil)).to be_nil
+    end
+
+    it "should return default value '' when key is not found" do
+      expect(hiera.call(scope, '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'")

data/spec/unit/functions4_spec.rb

@@ -177,7 +177,7 @@ actual:
     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()
+      f = create_function_with_optionals_and_repeated_via_dispatch()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_true
@@ -191,6 +191,39 @@ actual:
   min(Integer) - arg count {1}")
     end
 
+    it 'can create optional repeated parameter' do
+      f = create_function_with_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)
+
+      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,
+"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}")
+    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)
@@ -213,6 +246,10 @@ 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
@@ -563,7 +600,7 @@ actual:
     end
   end
 
-  def create_function_with_optionals_and_varargs_via_dispatch
+  def create_function_with_optionals_and_repeated_via_dispatch
     f = Puppet::Functions.create_function('min') do
       dispatch :min do
         param 'Numeric', :x
@@ -578,6 +615,39 @@ actual:
     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
@@ -608,6 +678,18 @@ actual:
     end
   end
 
+  def create_function_with_rq_repeated_after_opt
+    f = Puppet::Functions.create_function('t1') do
+      dispatch :t1 do
+        optional_param 'Numeric', :x
+        required_repeated_param 'Numeric', :y
+      end
+      def t1(x, *y)
+        x
+      end
+    end
+  end
+
   def create_function_with_param_after_repeated
     f = Puppet::Functions.create_function('t1') do
       dispatch :t1 do
@@ -692,6 +774,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