puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/unit/functions/shared.rb

@@ -2,19 +2,19 @@ shared_examples_for 'all functions transforming relative to absolute names' do |
   before(:each) do
     # mock that the class 'myclass' exists which are needed for the 'require' functions
     # as it checks the existence of the required class
-    @klass = double('class', :name => "myclass")
-    allow(@scope.environment.known_resource_types).to receive(:find_hostclass).and_return(@klass)
+    @klass = stub 'class', :name => "myclass"
+    @scope.environment.known_resource_types.stubs(:find_hostclass).returns(@klass)
     @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
-    allow(@scope).to receive(:resource).and_return(@resource)
+    @scope.stubs(:resource).returns @resource
   end
 
   it 'accepts a Class[name] type' do
-    expect(@scope.compiler).to receive(:evaluate_classes).with(["::myclass"], @scope, false)
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
     @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.host_class('myclass')])
   end
 
   it 'accepts a Resource[class, name] type' do
-    expect(@scope.compiler).to receive(:evaluate_classes).with(["::myclass"], @scope, false)
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
     @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
   end
 
@@ -45,6 +45,7 @@ shared_examples_for 'all functions transforming relative to absolute names' do |
 end
 
 shared_examples_for 'an inclusion function, regardless of the type of class reference,' do |function|
+
     it "and #{function} a class absolutely, even when a relative namespaced class of the same name is present" do
       catalog = compile_to_catalog(<<-MANIFEST)
         class foo {
@@ -80,6 +81,7 @@ shared_examples_for 'an inclusion function, regardless of the type of class refe
       MANIFEST
       expect(catalog.classes).to include('foo','bar')
     end
+
 end
 
 shared_examples_for 'an inclusion function, when --tasks is on,' do |function|
@@ -92,3 +94,4 @@ shared_examples_for 'an inclusion function, when --tasks is on,' do |function|
     end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
   end
 end
+

data/spec/unit/functions/size_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the size function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context 'for an array it' do
+    it 'returns 0 when empty' do
+      expect(compile_to_catalog("notify { String(size([])): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of elements when not empty' do
+      expect(compile_to_catalog("notify { String(size([1, 2, 3])): }")).to have_resource('Notify[3]')
+    end
+  end
+
+  context 'for a hash it' do
+    it 'returns 0 empty' do
+      expect(compile_to_catalog("notify { String(size({})): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of elements when not empty' do
+      expect(compile_to_catalog("notify { String(size({1=>1,2=>2})): }")).to have_resource('Notify[2]')
+    end
+  end
+
+  context 'for a string it' do
+    it 'returns 0 when empty' do
+      expect(compile_to_catalog("notify { String(size('')): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of characters when not empty' do
+      # note the multibyte characters - åäö each taking two bytes in UTF-8
+      expect(compile_to_catalog('notify { String(size("\u00e5\u00e4\u00f6")): }')).to have_resource('Notify[3]')
+    end
+  end
+
+  context 'for a binary it' do
+    it 'returns 0 when empty' do
+      expect(compile_to_catalog("notify { String(size(Binary(''))): }")).to have_resource('Notify[0]')
+    end
+
+    it 'returns number of bytes when not empty' do
+      expect(compile_to_catalog("notify { String(size(Binary('b25l'))): }")).to have_resource('Notify[3]')
+    end
+  end
+end

data/spec/unit/functions/sort_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the sort function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+    {
+      "'bac'"     => "'abc'",
+      "'BaC'"     => "'BCa'",
+    }.each_pair do |value, expected|
+      it "sorts characters in a string such that #{value}.sort results in #{expected}" do
+        expect(compile_to_catalog("notify { String( sort(#{value}) == #{expected}): }")).to have_resource("Notify[true]")
+      end
+    end
+
+  {
+     "'bac'"     => "'abc'",
+     "'BaC'"     => "'aBC'",
+   }.each_pair do |value, expected|
+     it "accepts a lambda when sorting characters in a string such that #{value} results in #{expected}" do
+       expect(compile_to_catalog("notify { String( sort(#{value}) |$a,$b| { compare($a,$b) } == #{expected}): }")).to have_resource("Notify[true]")
+     end
+   end
+
+  {
+    ['b', 'a', 'c']     => ['a', 'b', 'c'],
+    ['B', 'a', 'C']     => ['B', 'C', 'a'],
+  }.each_pair do |value, expected|
+    it "sorts strings in an array such that #{value}.sort results in #{expected}" do
+      expect(compile_to_catalog("notify { String( sort(#{value}) == #{expected}): }")).to have_resource("Notify[true]")
+    end
+  end
+
+  {
+    ['b', 'a', 'c']     => ['a', 'b', 'c'],
+    ['B', 'a', 'C']     => ['a', 'B', 'C'],
+  }.each_pair do |value, expected|
+    it "accepts a lambda when sorting an array such that #{value} results in #{expected}" do
+      expect(compile_to_catalog("notify { String( sort(#{value}) |$a,$b| { compare($a,$b) } == #{expected}): }")).to have_resource("Notify[true]")
+    end
+  end
+
+  it 'errors if given a mix of data types' do
+    expect { compile_to_catalog("sort([1, 'a'])")}.to raise_error(/comparison .* failed/)
+  end
+
+  it 'returns empty string for empty string input' do
+    expect(compile_to_catalog("notify { String(sort('') == ''): }")).to have_resource("Notify[true]")
+  end
+
+  it 'returns empty string for empty string input' do
+    expect(compile_to_catalog("notify { String(sort([]) == []): }")).to have_resource("Notify[true]")
+  end
+
+  it 'can sort mixed data types when using a lambda' do
+    # source sorts Numeric before string and uses compare() for same data type
+    src = <<-SRC
+    notify{ String(sort(['b', 3, 'a', 2]) |$a, $b| {
+        case [$a, $b] {
+          [String, Numeric] : { 1 }
+          [Numeric, String] : { -1 }
+          default:            { compare($a, $b) }
+        }
+      } == [2, 3,'a', 'b']):
+    }
+    SRC
+    expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+
+  end
+
+  it 'errors if lambda does not accept 2 arguments' do
+    expect { compile_to_catalog("sort([1, 'a']) || { }")}.to raise_error(/block expects 2 arguments/)
+    expect { compile_to_catalog("sort([1, 'a']) |$x| { }")}.to raise_error(/block expects 2 arguments/)
+    expect { compile_to_catalog("sort([1, 'a']) |$x,$y, $z| { }")}.to raise_error(/block expects 2 arguments/)
+  end
+end

data/spec/unit/functions/split_spec.rb

@@ -4,14 +4,13 @@ require 'puppet/loaders'
 
 describe 'the split function' do
 
-  before(:all) do
+  before(:each) do
     loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
     Puppet.push_context({:loaders => loaders}, "test-examples")
   end
 
-  after(:all) do
-    Puppet::Pops::Loaders.clear
-    Puppet::pop_context()
+  after(:each) do
+    Puppet.pop_context()
   end
 
   def split(*args)

data/spec/unit/functions/strip_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the strip function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'removes leading and trailing whitepsace' do
+    expect(compile_to_catalog("notify { String(\" abc\t\n \".strip == 'abc'): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns the value if Numeric' do
+    expect(compile_to_catalog("notify { String(42.strip == 42): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns rstripped version of each entry in an array' do
+    expect(compile_to_catalog("notify { String([' a ', ' b ', ' c '].strip == ['a', 'b', 'c']): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns rstripped version of each entry in an Iterator' do
+    expect(compile_to_catalog("notify { String([' a ', ' b ', ' c '].reverse_each.strip == ['c', 'b', 'a']): }")).to have_resource('Notify[true]')
+  end
+
+  it 'errors when given a a nested Array' do
+    expect { compile_to_catalog("['a', 'b', ['c']].strip")}.to raise_error(/'strip' parameter 'arg' expects a value of type Numeric, String, or Iterable/)
+  end
+
+end

data/spec/unit/functions/upcase_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the upcase function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'returns upper case version of a string' do
+    expect(compile_to_catalog("notify { 'abc'.upcase: }")).to have_resource('Notify[ABC]')
+  end
+
+  it 'returns the value if Numeric' do
+    expect(compile_to_catalog("notify { String(42.upcase == 42): }")).to have_resource('Notify[true]')
+  end
+
+  it 'performs capitalize of international UTF-8 characters', :if => RUBY_VERSION >= "2.4" do
+    expect(compile_to_catalog("notify { 'åäö'.upcase: }")).to have_resource('Notify[ÅÄÖ]')
+  end
+
+  it 'returns upper case version of each entry in an array (recursively)' do
+    expect(compile_to_catalog("notify { String(['a', ['b', ['c']]].upcase == ['A', ['B', ['C']]]): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns upper case version of keys and values in a hash (recursively)' do
+    expect(compile_to_catalog("notify { String({'a'=>'b','c'=>{'d'=>'e'}}.upcase == {'A'=>'B', 'C'=>{'D'=>'E'}}): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns upper case version of keys and values in nested hash / array structure' do
+    expect(compile_to_catalog("notify { String({'a'=>['b'],'c'=>[{'d'=>'e'}]}.upcase == {'A'=>['B'],'C'=>[{'D'=>'E'}]}): }")).to have_resource('Notify[true]')
+  end
+
+end

data/spec/unit/functions/versioncmp_spec.rb

@@ -3,13 +3,13 @@ require 'puppet/pops'
 require 'puppet/loaders'
 
 describe "the versioncmp function" do
-  before(:all) do
+
+  before(:each) do
     loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
     Puppet.push_context({:loaders => loaders}, "test-examples")
   end
 
-  after(:all) do
-    Puppet::Pops::Loaders.clear
+  after(:each) do
     Puppet::pop_context()
   end
 
@@ -28,7 +28,7 @@ describe "the versioncmp function" do
   end
 
   it "should call Puppet::Util::Package.versioncmp (included in scope)" do
-    expect(Puppet::Util::Package).to receive(:versioncmp).with('1.2', '1.3').and_return(-1)
+    Puppet::Util::Package.expects(:versioncmp).with('1.2', '1.3').returns(-1)
 
     expect(versioncmp('1.2', '1.3')).to eq(-1)
   end

data/spec/unit/functions4_spec.rb

@@ -392,11 +392,11 @@ describe 'the 4x function api' do
     end
 
     context 'supports calling other functions' do
-      before(:all) do
+      before(:each) do
         Puppet.push_context( {:loaders => Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))})
       end
 
-      after(:all) do
+      after(:each) do
         Puppet.pop_context()
       end
 
@@ -425,12 +425,12 @@ describe 'the 4x function api' do
       end
     end
 
-    context 'supports calling ruby functions with lambda from puppet' do
-      before(:all) do
+    context 'functions in a context with a compiler' do
+      before(:each) do
         Puppet.push_context( {:loaders => Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))})
       end
 
-      after(:all) do
+      after(:each) do
         Puppet.pop_context()
       end
 
@@ -443,28 +443,37 @@ describe 'the 4x function api' do
       let(:scope) { s = create_test_scope_for_node(node); s }
       let(:loader) { Puppet::Pops::Loaders.find_loader(nil) }
 
-      it 'function with required block can be called' do
-        # construct ruby function to call
-        fc = Puppet::Functions.create_function('testing::test') do
-          dispatch :test do
-            param 'Integer', :x
-            # block called 'the_block', and using "all_callables"
-            required_block_param #(all_callables(), 'the_block')
-          end
-          def test(x)
-            # call the block with x
-            yield(x)
+      context 'supports calling ruby functions with lambda from puppet' do
+        it 'function with required block can be called' do
+          # construct ruby function to call
+          fc = Puppet::Functions.create_function('testing::test') do
+            dispatch :test do
+              param 'Integer', :x
+              # block called 'the_block', and using "all_callables"
+              required_block_param #(all_callables(), 'the_block')
+            end
+            def test(x)
+              # call the block with x
+              yield(x)
+            end
           end
+          # add the function to the loader (as if it had been loaded from somewhere)
+          the_loader = loader
+          f = fc.new({}, the_loader)
+          loader.set_entry(Puppet::Pops::Loader::TypedName.new(:function, 'testing::test'), f)
+          # evaluate a puppet call
+          source = "testing::test(10) |$x| { $x+1 }"
+          program = parser.parse_string(source, __FILE__)
+          Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns(the_loader)
+          expect(parser.evaluate(scope, program)).to eql(11)
         end
-        # add the function to the loader (as if it had been loaded from somewhere)
-        the_loader = loader
-        f = fc.new({}, the_loader)
-        loader.set_entry(Puppet::Pops::Loader::TypedName.new(:function, 'testing::test'), f)
-        # evaluate a puppet call
-        source = "testing::test(10) |$x| { $x+1 }"
-        program = parser.parse_string(source, __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(the_loader)
-        expect(parser.evaluate(scope, program)).to eql(11)
+      end
+
+      it 'supports injection of a cache' do
+        the_function = create_function_with_cache_param.new(:closure_scope, :loader)
+        expect(the_function.call(scope, 'key', 10)).to eql(nil)
+        expect(the_function.call(scope, 'key', 20)).to eql(10)
+        expect(the_function.call(scope, 'key', 30)).to eql(20)
       end
     end
 
@@ -508,8 +517,8 @@ describe 'the 4x function api' do
           CODE
         end.to raise_error(/Parsing of type string '"Array\[1\+=1\]"' failed with message: <Syntax error at '\]' \(line: 1, column: [0-9]+\)>/m)
       end
-
     end
+
     context 'can use a loader when parsing types in function dispatch, and' do
       let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
 
@@ -529,7 +538,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test(10)', __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        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
@@ -551,7 +560,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test(10)', __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eql(10)
       end
 
@@ -570,7 +579,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test(10)', __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        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
 
@@ -592,7 +601,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string('testing::test([10,20])', __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eq([10,20])
       end
 
@@ -615,7 +624,7 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string("testing::test({'x' => [10,20]})", __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).returns(the_loader)
         expect(parser.evaluate({}, program)).to eq({'x' => [10,20]})
       end
 
@@ -637,12 +646,13 @@ describe 'the 4x function api' do
         CODE
         the_loader.add_function('testing::test', fc.new({}, the_loader))
         program = parser.parse_string("testing::test({'x' => {'y' => 'n'}})", __FILE__)
-        expect(Puppet::Pops::Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(the_loader)
+        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
     Puppet::Functions.create_function('test') do
       def test()
@@ -853,25 +863,26 @@ describe 'the 4x function api' do
     end
   end
 
-  def create_function_with_param_injection_regular
-    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"
-
-      dispatch :test do
-        injected_param Puppet::Pops::Types::TypeFactory.string, :x, 'a_string'
-        injected_producer_param Puppet::Pops::Types::TypeFactory.integer, :y, 'an_int'
-        param 'Scalar', :a
-        param 'Scalar', :b
-      end
-
-      def test(x,y,a,b)
-        y_produced = y.produce(nil)
-        "#{x}! #{a}, and #{b} < #{y_produced} = #{ !!(a < y_produced && b < y_produced)}"
-      end
-    end
-  end
+# DEAD TODO REMOVE
+#  def create_function_with_param_injection_regular
+#    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"
+#
+#      dispatch :test do
+#        injected_param Puppet::Pops::Types::TypeFactory.string, :x, 'a_string'
+#        injected_producer_param Puppet::Pops::Types::TypeFactory.integer, :y, 'an_int'
+#        param 'Scalar', :a
+#        param 'Scalar', :b
+#      end
+#
+#      def test(x,y,a,b)
+#        y_produced = y.produce(nil)
+#        "#{x}! #{a}, and #{b} < #{y_produced} = #{ !!(a < y_produced && b < y_produced)}"
+#      end
+#    end
+#  end
 
   def create_function_with_required_block_all_defaults
     Puppet::Functions.create_function('test') do
@@ -1000,6 +1011,22 @@ describe 'the 4x function api' do
     end
   end
 
+  def create_function_with_cache_param
+    Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
+      dispatch :test do
+        cache_param
+        param 'String', :key
+        param 'Any', :value
+      end
+      def test(cache, k, v)
+        h = cache.retrieve(self)
+        previous = h[k]
+        h[k] = v
+        previous
+      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)