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

data/spec/unit/functions/chop_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the chop function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'removes last character in a string' do
+    expect(compile_to_catalog("notify { String('abc'.chop == 'ab'): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns empty string for an empty string' do
+    expect(compile_to_catalog("notify { String(''.chop == ''): }")).to have_resource('Notify[true]')
+  end
+
+  it 'removes both CR LF if both are the last characters in a string' do
+    expect(compile_to_catalog("notify { String(\"abc\r\n\".chop == 'abc'): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns the value if Numeric' do
+    expect(compile_to_catalog("notify { String(42.chop == 42): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns chopped version of each entry in an array' do
+    expect(compile_to_catalog("notify { String(['aa', 'ba', 'ca'].chop == ['a', 'b', 'c']): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns chopped version of each entry in an Iterator' do
+    expect(compile_to_catalog("notify { String(['aa', 'bb', 'cc'].reverse_each.chop == ['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']].chop")}.to raise_error(/'chop' parameter 'arg' expects a value of type Numeric, String, or Iterable/)
+  end
+
+end

data/spec/unit/functions/compare_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the compare function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  {
+    [0, 1]     => -1,
+    [1, 0]     => 1,
+    [1, 1]     => 0,
+    [0.0, 1.0] => -1,
+    [1.0, 0.0] => 1,
+    [1.0, 1.0] => 0,
+    [0.0, 1]   => -1,
+    [1.0, 0]   => 1,
+    [1.0, 1]   => 0,
+    [0, 1.0]   => -1,
+    [1, 0.0]   => 1,
+    [1, 1.0]   => 0,
+  }.each_pair do |values, expected|
+    it "compares numeric/numeric such that compare(#{values[0]}, #{values[1]}) returns #{expected}" do
+      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+    end
+  end
+
+  {
+    ['"a"', '"b"'] => -1,
+    ['"b"', '"a"'] => 1,
+    ['"b"', '"b"'] => 0,
+    ['"A"', '"b"'] => -1,
+    ['"B"', '"a"'] => 1,
+    ['"B"', '"b"'] => 0,
+  }.each_pair do |values, expected|
+    it "compares String values by default such that compare(#{values[0]}, #{values[1]}) returns #{expected}" do
+      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+    end
+
+    it "compares String values with third true arg such that compare(#{values[0]}, #{values[1]}, true) returns #{expected}" do
+      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}, true) == #{expected}): }")).to have_resource("Notify[true]")
+    end
+  end
+
+  {
+    ['"a"', '"b"'] => -1,
+    ['"b"', '"a"'] => 1,
+    ['"b"', '"b"'] => 0,
+    ['"A"', '"b"'] => -1,
+    ['"B"', '"a"'] => -1,
+    ['"B"', '"b"'] => -1,
+  }.each_pair do |values, expected|
+    it "compares String values with third arg false such that compare(#{values[0]}, #{values[1]}, false) returns #{expected}" do
+      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}, false) == #{expected}): }")).to have_resource("Notify[true]")
+    end
+  end
+
+  {
+    ["Semver('1.0.0')", "Semver('2.0.0')"] => -1,
+    ["Semver('2.0.0')", "Semver('1.0.0')"] => 1,
+    ["Semver('2.0.0')", "Semver('2.0.0')"] => 0,
+  }.each_pair do |values, expected|
+    it "compares Semver values such that compare(#{values[0]}, #{values[1]}) returns #{expected}" do
+      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+    end
+  end
+
+  {
+    ["Timespan(1)", "Timespan(2)"] => -1,
+    ["Timespan(2)", "Timespan(1)"] => 1,
+    ["Timespan(1)", "Timespan(1)"] => 0,
+    ["Timespan(1)", 2] => -1,
+    ["Timespan(2)", 1] => 1,
+    ["Timespan(1)", 1] => 0,
+    [1, "Timespan(2)"] => -1,
+    [2, "Timespan(1)"] => 1,
+    [1, "Timespan(1)"] => 0,
+
+    ["Timestamp(1)", "Timestamp(2)"] => -1,
+    ["Timestamp(2)", "Timestamp(1)"] => 1,
+    ["Timestamp(1)", "Timestamp(1)"] => 0,
+    ["Timestamp(1)", 2] => -1,
+    ["Timestamp(2)", 1] => 1,
+    ["Timestamp(1)", 1] => 0,
+    [1, "Timestamp(2)"] => -1,
+    [2, "Timestamp(1)"] => 1,
+    [1, "Timestamp(1)"] => 0,
+
+  }.each_pair do |values, expected|
+    it "compares time values such that compare(#{values[0]}, #{values[1]}) returns #{expected}" do
+      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+    end
+  end
+
+  context "errors when" do
+    [ [true, false],
+      ['/x/', '/x/'],
+      ['undef', 'undef'],
+      ['undef', 1],
+      [1, 'undef'],
+      [[1], [1]],
+      [{'a' => 1}, {'b' => 1}],
+    ].each do |a, b|
+      it "given values of non comparable types #{a.class}, #{b.class}" do
+        expect { compile_to_catalog("compare(#{a},#{b})")}.to raise_error(/Non comparable type/)
+      end
+    end
+
+    [
+      [10, '"hello"'],
+      ['"hello"', 10],
+      [10.0, '"hello"'],
+      ['"hello"', 10.0],
+      ['Timespan(1)', '"hello"'],
+      ['Timestamp(1)', '"hello"'],
+      ['Timespan(1)', 'Semver("1.2.3")'],
+      ['Timestamp(1)', 'Semver("1.2.3")'],
+    ].each do |a, b|
+      it "given values of comparable, but incompatible types #{a.class}, #{b.class}" do
+        expect { compile_to_catalog("compare(#{a},#{b})")}.to raise_error(/Can only compare values of the same type/)
+      end
+    end
+
+      [
+        [10, 10],
+        [10.0, 10],
+        ['Timespan(1)', 'Timespan(1)'],
+        ['Timestamp(1)', 'Timestamp(1)'],
+        ['Semver("1.2.3")', 'Semver("1.2.3")'],
+      ].each do |a, b|
+        it "given ignore case true when values are comparable, but not both being strings" do
+          expect { compile_to_catalog("compare(#{a},#{b}, true)")}.to raise_error(/can only be used when comparing strings/)
+        end
+        it "given ignore case false when values are comparable, but not both being strings" do
+          expect { compile_to_catalog("compare(#{a},#{b}, false)")}.to raise_error(/can only be used when comparing strings/)
+        end
+      end
+
+      it "given more than three arguments" do
+          expect { compile_to_catalog("compare('a','b', false, false)")}.to raise_error(/Accepts at most 3 arguments, got 4/)
+      end
+  end
+
+  # Error if not the same except Timestamp and Timespan that accepts Numeric on either side
+  # Error for non supported - Boolean, Regexp, etc
+end

data/spec/unit/functions/contain_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet/parser/functions'
@@ -6,6 +7,7 @@ require 'matchers/resource'
 require 'matchers/include_in_order'
 require 'unit/functions/shared'
 
+
 describe 'The "contain" function' do
   include PuppetSpec::Compiler
   include ContainmentMatchers

data/spec/unit/functions/convert_to_spec.rb

@@ -19,4 +19,7 @@ describe 'the convert_to function' do
     expect(compile_to_catalog('notify{ "testing-${[a,1].convert_to(Hash) |$x| { yay }}": }')).to have_resource('Notify[testing-yay]')
   end
 
+  it 'passes on additional arguments to the new function' do
+    expect(compile_to_catalog('"111".convert_to(Integer, 2) |$x| { notify { "testing-${x}": } }')).to have_resource('Notify[testing-7]')
+  end
 end

data/spec/unit/functions/defined_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/loaders'

data/spec/unit/functions/downcase_spec.rb

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

data/spec/unit/functions/epp_spec.rb

@@ -153,7 +153,7 @@ describe "the epp function" do
     filename = File.join(file_path, "template.epp")
     File.open(filename, "wb+") { |f| f.write(content) }
 
-    allow(Puppet::Parser::Files).to receive(:find_template).and_return(filename)
+    Puppet::Parser::Files.stubs(:find_template).returns(filename)
     epp_function.call(scope, 'template', args_hash)
   end
 
@@ -162,7 +162,7 @@ describe "the epp function" do
     filename = File.join(file_path, "template.epp")
     File.open(filename, "wb+") { |f| f.write(content) }
 
-    allow(Puppet::Parser::Files).to receive(:find_template).and_return(filename)
+    Puppet::Parser::Files.stubs(:find_template).returns(filename)
     epp_function.call(scope, 'template')
   end
 

data/spec/unit/functions/filter_spec.rb

@@ -122,18 +122,18 @@ describe 'the filter method' do
     expect(catalog).to have_resource("File[/file_blueb]").with_parameter(:ensure, 'present')
   end
 
-  it 'filters on an array will not include elements for which the block returns truthy but not true' do
+  it 'filters on an array will include elements for which the block returns truthy' do
     catalog = compile_to_catalog(<<-MANIFEST)
-      $r = [1, 2, 3].filter |$v| { $v } == []
+      $r = [1, 2, false, undef].filter |$v| { $v } == [1, 2]
       notify { "eval_${$r}": }
     MANIFEST
 
     expect(catalog).to have_resource('Notify[eval_true]')
   end
 
-  it 'filters on a hash will not include elements for which the block returns truthy but not true' do
+  it 'filters on a hash will not include elements for which the block returns truthy' do
     catalog = compile_to_catalog(<<-MANIFEST)
-      $r = {a => 1, b => 2, c => 3}.filter |$k, $v| { $v } == {}
+      $r = {a => 1, b => 2, c => false, d=> undef}.filter |$k, $v| { $v } == {a => 1, b => 2}
       notify { "eval_${$r}": }
     MANIFEST
 

data/spec/unit/functions/find_file_spec.rb

@@ -42,27 +42,27 @@ describe 'the find_file function' do
 
   it 'finds an existing file in a module' do
     with_file_content('file content') do |name|
-      mod = double('module')
-      allow(mod).to receive(:file).with('myfile').and_return(name)
+      mod = mock 'module'
+      mod.stubs(:file).with('myfile').returns(name)
       Puppet[:code] = "notify { find_file('mymod/myfile'):}"
       node = Puppet::Node.new('localhost')
       compiler = Puppet::Parser::Compiler.new(node)
-      allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
+      compiler.environment.stubs(:module).with('mymod').returns(mod)
 
       expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[#{name}]")
     end
   end
 
   it 'returns undef when none of the paths were found' do
-    mod = double('module')
-    allow(mod).to receive(:file).with('myfile').and_return(nil)
+    mod = mock 'module'
+    mod.stubs(:file).with('myfile').returns(nil)
     Puppet[:code] = "notify { String(type(find_file('mymod/myfile', 'nomod/nofile'))):}"
     node = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
     # For a module that does not have the file
-    allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
+    compiler.environment.stubs(:module).with('mymod').returns(mod)
     # For a module that does not exist
-    allow(compiler.environment).to receive(:module).with('nomod').and_return(nil)
+    compiler.environment.stubs(:module).with('nomod').returns(nil)
 
     expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[Undef]")
   end

data/spec/unit/functions/floor_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the floor function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context 'for an integer' do
+    [ 0, 1, -1].each do |x|
+      it "called as floor(#{x}) results in the same value" do
+        expect(compile_to_catalog("notify { String( floor(#{x}) == #{x}): }")).to have_resource("Notify[true]")
+      end
+    end
+  end
+
+  context 'for a float' do
+    {
+      0.0 => 0,
+      1.1 => 1,
+      -1.1 => -2,
+    }.each_pair do |x, expected|
+      it "called as floor(#{x}) results in #{expected}" do
+        expect(compile_to_catalog("notify { String( floor(#{x}) == #{expected}): }")).to have_resource("Notify[true]")
+      end
+    end
+  end
+
+  context 'for a string' do
+    let(:logs) { [] }
+    let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
+    { "0" => 0,
+      "1" => 1,
+      "-1" => -1,
+      "0.0" => 0,
+      "1.1" => 1,
+      "-1.1" => -2,
+      "0777" => 777,
+      "-0777" => -777,
+      "0xFF" => 0xFF,
+    }.each_pair do |x, expected|
+      it "called as floor('#{x}') results in #{expected} and a deprecation warning" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( floor('#{x}') == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+
+    ['blue', '0.2.3'].each do |x|
+      it "errors as the string '#{x}' cannot be converted to a float (indirectly deprecated)" do
+        expect{ compile_to_catalog("floor('#{x}')") }.to raise_error(/cannot convert given value to a floating point value/)
+      end
+    end
+  end
+
+  [[1,2,3], {'a' => 10}].each do |x|
+    it "errors for a value of class #{x.class} (indirectly deprecated)" do
+      expect{ compile_to_catalog("floor(#{x})") }.to raise_error(/expects a value of type Numeric or String/)
+    end
+  end
+
+end

data/spec/unit/functions/get_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the get function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context 'returns undef value' do
+    it 'when result is undef due to given undef' do
+      expect( evaluate(source: "get(undef, '')")).to be_nil
+    end
+
+    it 'when result is undef due to navigation into undef' do
+      expect( evaluate(source: "get(undef, '0')")).to be_nil
+    end
+
+    it 'when navigation results in explicit undef in an array' do
+      expect( evaluate(source: "get([undef], '0')")).to be_nil
+    end
+
+    it 'when navigation results in explicit undef in a hash' do
+      expect( evaluate(source: "get(a => undef, 'a')")).to be_nil
+    end
+
+    it 'when navigation references unavailable value in an array' do
+      expect( evaluate(source: "get([1], '2')")).to be_nil
+    end
+
+    it 'when navigation references unavailable value in a hash' do
+      expect( evaluate(source: "get(a => 43, 'b')")).to be_nil
+    end
+  end
+
+  context 'returns default value' do
+    it 'when result is undef due to given undef' do
+      expect( evaluate(source: "get(undef, '', 'ok')")).to eql('ok')
+    end
+
+    it 'when result is undef due to navigation into undef' do
+      expect( evaluate(source: "get(undef, '0', 'ok')")).to eql('ok')
+    end
+
+    it 'when navigation results in explicit undef in array' do
+      expect( evaluate(source: "get([undef], '0', 'ok')")).to eql('ok')
+    end
+
+    it 'when navigation results in explicit undef in hash' do
+      expect( evaluate(source: "get(a => undef, 'a', 'ok')")).to eql('ok')
+    end
+
+    it 'when navigation references unavailable value in an array' do
+      expect( evaluate(source: "get([1], '2', 'ok')")).to eql('ok')
+    end
+
+    it 'when navigation references unavailable value in a hash' do
+      expect( evaluate(source: "get(a => 43, 'b', 'ok')")).to eql('ok')
+    end
+  end
+
+  it 'returns value if given empty navigation' do
+    expect(evaluate(source: "get('ok', '')")).to eql('ok')
+  end
+
+  it 'navigates into array as given by navigation string' do
+    expect( evaluate( source: "get(['nope', ['ok']], '1.0')")).to eql('ok')
+  end
+
+  it 'navigates into hash as given by navigation string' do
+    expect( evaluate( source: "get(a => 'nope', b=> ['ok'], 'b.0')")).to eql('ok')
+  end
+
+  it 'navigates into hash with numeric key' do
+    expect( evaluate( source: "get(a => 'nope', 0=> ['ok'], '0.0')")).to eql('ok')
+  end
+
+  it 'navigates into hash with numeric string but requires quoting' do
+    expect( evaluate( source: "get(a => 'nope', '0'=> ['ok'], '\"0\".0')")).to eql('ok')
+  end
+
+  it 'can navigate a key with . when it is quoted' do
+    expect(
+      evaluate(
+        variables: {'x' => {'a.b' => ['nope', ['ok']]}},
+        source: "get($x, '\"a.b\".1.0')"
+      )
+    ).to eql('ok')
+  end
+
+  it 'an error is raised when navigating with string key into an array' do
+    expect {
+      evaluate(source: "get(['nope', ['ok']], '1.blue')")
+    }.to raise_error(/The given data requires an Integer index/)
+  end
+
+  it 'calls a given block with EXPECTED_INTEGER_INDEX if navigating into array with string' do
+    expect(evaluate(
+             source:
+               "get(['nope', ['ok']], '1.blue') |$error| {
+                   if $error.issue_code =~ /^EXPECTED_INTEGER_INDEX$/ {'ok'} else { 'nope'}
+                }"
+           )).to eql('ok')
+  end
+
+  it 'calls a given block with EXPECTED_COLLECTION if navigating into something not Undef or Collection' do
+    expect(evaluate(
+             source:
+               "get(['nope', /nah/], '1.blue') |$error| {
+                  if $error.issue_code =~ /^EXPECTED_COLLECTION$/ {'ok'} else { 'nope'}
+               }"
+           )).to eql('ok')
+  end
+
+  context 'it does not pick the default value when undef is returned by error handling block' do
+    it 'for "expected integer" case' do
+      expect(evaluate(
+               source: "get(['nope', ['ok']], '1.blue', 'nope') |$msg| { undef }"
+             )).to be_nil
+    end
+
+    it 'for "expected collection" case' do
+      expect(evaluate(
+               source: "get(['nope', /nah/], '1.blue') |$msg| { undef }"
+             )).to be_nil
+    end
+  end
+
+  it 'does not call a given block if navigation string has syntax error' do
+    expect {
+      evaluate(source: "get(['nope', /nah/], '1....') |$msg| { fail('so sad') }")
+    }.to raise_error(/Syntax error/)
+  end
+
+end