puppet 5.0.0 → 6.0.0

data/spec/unit/functions/max_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the max function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  let(:logs) { [] }
+  let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
+  it 'errors if not give at least one argument' do
+    expect{ compile_to_catalog("max()") }.to raise_error(/Wrong number of arguments need at least one/)
+  end
+
+  context 'compares numbers' do
+    { [0, 1]    => 1,
+      [-1, 0]   => 0,
+      [-1.0, 0] => 0,
+    }.each_pair do |values, expected|
+      it "called as max(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        expect(compile_to_catalog("notify { String( max(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+      end
+    end
+  end
+
+  context 'compares strings that are not numbers without deprecation warning' do
+    it "string as number is deprecated" do
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        expect(compile_to_catalog("notify { String( max('a', 'b') == 'b'): }")).to have_resource("Notify[true]")
+      end
+      expect(warnings).to_not include(/auto conversion of .* is deprecated/)
+    end
+  end
+
+  context 'compares strings as numbers if possible and issues deprecation warning' do
+    {
+      [20, "'100'"]     => "'100'",
+      ["'20'", "'100'"] => "'100'",
+      ["'20'", 100]     => "100",
+      [20, "'100x'"]    => "20",
+      ["20", "'100x'"]  => "20",
+      ["'20x'", 100]    => "'20x'",
+    }.each_pair do |values, expected|
+      it "called as max(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( max(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+
+    {
+      [20, "'1e2'"] => "'1e2'",
+      [20, "'1E2'"] => "'1E2'",
+      [20, "'10_0'"] => "'10_0'",
+      [20, "'100.0'"] => "'100.0'",
+    }.each_pair do |values, expected|
+      it "called as max(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( max(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+
+  end
+
+  context 'compares all except numeric and string by conversion to string and issues deprecation warning' do
+    {
+      [[20], "'a'"]                  => "'a'",            # after since '[' is before 'a'
+      ["{'a' => 10}", "'a'"]         => "{'a' => 10}",    # after since '{' is after 'a'
+      [false, 'fal']                 => "false",          # the boolean since text 'false' is longer
+      ['/b/', "'(?-mix:c)'"]         => "'(?-mix:c)'",    # because regexp to_s is a (?-mix:b) string
+      ["Timestamp(1)", "'1980 a.d'"] => "'1980 a.d'",     # because timestamp to_s is a date-time string here starting with 1970
+      ["Semver('2.0.0')", "Semver('10.0.0')"] => "Semver('2.0.0')", # "10.0.0" is lexicographically before "2.0.0"
+    }.each_pair do |values, expected|
+      it "called as max(#{values[0]}, #{values[1]}) results in the value #{expected} and issues deprecation warning" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( max(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+  end
+
+  it "accepts a lambda that takes over the comparison (here avoiding the string as number conversion)" do
+    src = <<-SRC
+      $val = max("2", "10") |$a, $b| { compare($a, $b) }
+      notify { String( $val == "2"): }
+    SRC
+    expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+  end
+
+  context 'compares entries in a single array argument as if they were splatted as individual args' do
+    {
+      [1,2,3] => 3,
+      ["1", "2","3"] => "'3'",
+      [1, "2", 3] => 3,
+    }.each_pair do |value, expected|
+      it "called as max(#{value}) results in the value #{expected}" do
+        src = "notify { String( max(#{value}) == #{expected}): }"
+        expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+      end
+    end
+
+    {
+      [1,2,3] => 3,
+      ["10","2","3"] => "'3'",
+      [1,"x",3] => "'x'",
+    }.each_pair do |value, expected|
+      it "called as max(#{value}) with a lambda using compare() results in the value #{expected}" do
+        src = <<-"SRC"
+        function s_after_n($a,$b) {
+          case [$a, $b] {
+            [String, Numeric]: { 1 }
+            [Numeric, String]: { -1 }
+            default: { compare($a, $b) }
+          }
+        }
+        notify { String( max(#{value}) |$a,$b| {s_after_n($a,$b) } == #{expected}): }
+        SRC
+        expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+      end
+    end
+
+  end
+end

data/spec/unit/functions/min_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the min function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  let(:logs) { [] }
+  let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
+  it 'errors if not give at least one argument' do
+    expect{ compile_to_catalog("min()") }.to raise_error(/Wrong number of arguments need at least one/)
+  end
+
+  context 'compares numbers' do
+    { [0, 1]    => 0,
+      [-1, 0]   => -1,
+      [-1.0, 0] => -1.0,
+    }.each_pair do |values, expected|
+      it "called as min(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        expect(compile_to_catalog("notify { String( min(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+      end
+    end
+  end
+
+  context 'compares strings that are not numbers without deprecation warning' do
+    it "string as number is deprecated" do
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        expect(compile_to_catalog("notify { String( min('a', 'b') == 'a'): }")).to have_resource("Notify[true]")
+      end
+      expect(warnings).to_not include(/auto conversion of .* is deprecated/)
+    end
+  end
+
+  context 'compares strings as numbers if possible and outputs deprecation warning' do
+    {
+      [20, "'100'"] => 20,
+      ["'20'", "'100'"] => "'20'",
+      ["'20'", 100] => "'20'",
+      [20, "'100x'"] => "'100x'",
+      ["20", "'100x'"] => "'100x'",
+      ["'20x'", 100] => 100,
+    }.each_pair do |values, expected|
+      it "called as min(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( min(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+
+    {
+      [20, "'1e2'"] => 20,
+      [20, "'1E2'"] => 20,
+      [20, "'10_0'"] => 20,
+      [20, "'100.0'"] => 20,
+    }.each_pair do |values, expected|
+      it "called as min(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( min(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+
+  end
+
+  context 'compares all except numeric and string by conversion to string (and issues deprecation warning)' do
+    {
+      [[20], "'a'"]                  => [20],             # before since '[' is before 'a'
+      ["{'a' => 10}", "'|a'"]         => "{'a' => 10}",   # before since '{' is before '|'
+      [false, 'fal']                 => "'fal'",          # 'fal' before since shorter than 'false'
+      ['/b/', "'(?-mix:a)'"]         => "'(?-mix:a)'",    # because regexp to_s is a (?-mix:b) string
+      ["Timestamp(1)", "'1556 a.d'"] => "'1556 a.d'",     # because timestamp to_s is a date-time string here starting with 1970
+      ["Semver('2.0.0')", "Semver('10.0.0')"] => "Semver('10.0.0')", # "10.0.0" is lexicographically before "2.0.0"
+    }.each_pair do |values, expected|
+      it "called as min(#{values[0]}, #{values[1]}) results in the value #{expected} and issues deprecation warning" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( min(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+  end
+
+  it "accepts a lambda that takes over the comparison (here avoiding the string as number conversion)" do
+    src = <<-SRC
+      $val = min("2", "10") |$a, $b| { compare($a, $b) }
+      notify { String( $val == "10"): }
+    SRC
+    expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+  end
+
+  context 'compares entries in a single array argument as if they were splatted as individual args' do
+    {
+      [1,2,3] => 1,
+      ["1", "2","3"] => "'1'",
+      [1,"2",3] => 1,
+    }.each_pair do |value, expected|
+      it "called as max(#{value}) results in the value #{expected}" do
+        src = "notify { String( min(#{value}) == #{expected}): }"
+        expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+      end
+    end
+
+    {
+      [1,2,3] => 1,
+      ["10","2","3"] => "'10'",
+      [1,"x",3] => "'x'",
+    }.each_pair do |value, expected|
+      it "called as max(#{value}) with a lambda using compare() results in the value #{expected}" do
+        src = <<-"SRC"
+        function n_after_s($a,$b) {
+          case [$a, $b] {
+            [String, Numeric]: { -1 }
+            [Numeric, String]: { 1 }
+            default: { compare($a, $b) }
+          }
+        }
+        notify { String( min(#{value}) |$a,$b| {n_after_s($a,$b) } == #{expected}): }
+        SRC
+        expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+      end
+    end
+
+  end
+end

data/spec/unit/functions/module_directory_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+require 'puppet_spec/files'
+
+describe 'the module_directory function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+  include PuppetSpec::Files
+
+  it 'returns first found module from one or more given names' do
+    mod = mock 'module'
+    mod.stubs(:path).returns('expected_path')
+    Puppet[:code] = "notify { module_directory('one', 'two'):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.environment.stubs(:module).with('one').returns(nil)
+    compiler.environment.stubs(:module).with('two').returns(mod)
+    expect(compiler.compile()).to have_resource("Notify[expected_path]")
+  end
+
+  it 'returns first found module from one or more given names in an array' do
+    mod = mock 'module'
+    mod.stubs(:path).returns('expected_path')
+    Puppet[:code] = "notify { module_directory(['one', 'two']):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.environment.stubs(:module).with('one').returns(nil)
+    compiler.environment.stubs(:module).with('two').returns(mod)
+    expect(compiler.compile()).to have_resource("Notify[expected_path]")
+  end
+
+  it 'returns undef when none of the modules were found' do
+    mod = mock 'module'
+    mod.stubs(:path).returns('expected_path')
+    Puppet[:code] = "notify { String(type(module_directory('one', 'two'))):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.environment.stubs(:module).with('one').returns(nil)
+    compiler.environment.stubs(:module).with('two').returns(nil)
+    expect(compiler.compile()).to have_resource("Notify[Undef]")
+  end
+end

data/spec/unit/functions/new_spec.rb

@@ -28,7 +28,7 @@ describe 'the new function' do
       $x = Integer.new(undef)
       notify { "one${x}word": }
     MANIFEST
-    )}.to raise_error(Puppet::Error, /expects an Integer value, got Undef/)
+    )}.to raise_error(Puppet::Error, /of type Undef cannot be converted to Integer/)
   end
 
   it 'errors if converted value is not assignable to the type' do
@@ -39,6 +39,26 @@ describe 'the new function' do
     )}.to raise_error(Puppet::Error, /expects an Integer\[1, 5\] value, got Integer\[42, 42\]/)
   end
 
+  it 'accepts and returns a second parameter that is an instance of the first, even when the type has no backing new_function' do
+    expect(eval_and_collect_notices(<<-MANIFEST)).to eql(%w(true true true true true true))
+      notice(undef == Undef(undef))
+
+      notice(default == Default(default))
+
+      notice(Any == Type(Any))
+
+      $b = Binary('YmluYXI=')
+      notice($b == Binary($b))
+
+      $t = Timestamp('2012-03-04T09:10:11.001')
+      notice($t == Timestamp($t))
+
+      type MyObject = Object[{attributes => {'type' => String}}]
+      $o = MyObject('Remote')
+      notice($o == MyObject($o))
+    MANIFEST
+  end
+
   context 'when invoked on NotUndef' do
     it 'produces an instance of the NotUndef nested type' do
       expect(compile_to_catalog(<<-MANIFEST
@@ -274,11 +294,11 @@ describe 'the new function' do
         '+ 0XGG'=> :error,
         '- 0XGG'=> :error,
       }.each do |str, result|
-        it "errors when given the non octal value compliant string '#{str}'" do
+        it "errors when given the non hexadecimal value compliant string '#{str}'" do
           expect{compile_to_catalog(<<-"MANIFEST"
             $x = Integer.new("#{str}", 8)
           MANIFEST
-        )}.to raise_error(Puppet::Error, /invalid value/)
+        )}.to raise_error(Puppet::Error, /The string '#{Regexp.escape(str)}' cannot be converted to Integer/)
         end
       end
     end
@@ -301,7 +321,7 @@ describe 'the new function' do
         '0b10'  => :error,
         '0B10'  => :error,
       }.each do |str, result|
-        it "errors when given the non octal value compliant string '#{str}'" do
+        it "errors when given the non binary value compliant string '#{str}'" do
           expect{compile_to_catalog(<<-"MANIFEST"
             $x = Integer.new("#{str}", 10)
           MANIFEST
@@ -332,28 +352,28 @@ describe 'the new function' do
         expect{compile_to_catalog(<<-"MANIFEST"
           $x = Integer.new('10', 3)
         MANIFEST
-      )}.to raise_error(Puppet::Error, /rejected: parameter 'radix'/m)
+      )}.to raise_error(Puppet::Error, /Illegal radix/)
       end
 
       it 'radix is wrong and when given in long form' do
         expect{compile_to_catalog(<<-"MANIFEST"
           $x = Integer.new({from =>'10', radix=>3})
         MANIFEST
-      )}.to raise_error(Puppet::Error, /rejected: parameter 'hash_args' entry 'radix'/m)
+      )}.to raise_error(Puppet::Error, /Illegal radix/)
       end
 
       it 'value is not numeric and given directly' do
         expect{compile_to_catalog(<<-"MANIFEST"
           $x = Integer.new('eleven', 10)
         MANIFEST
-      )}.to raise_error(Puppet::Error, /invalid value/)
+      )}.to raise_error(Puppet::Error, /The string 'eleven' cannot be converted to Integer/)
       end
 
       it 'value is not numeric and given in long form' do
         expect{compile_to_catalog(<<-"MANIFEST"
       $x = Integer.new({from => 'eleven', radix => 10})
         MANIFEST
-      )}.to raise_error(Puppet::Error, /invalid value/)
+      )}.to raise_error(Puppet::Error, /The string 'eleven' cannot be converted to Integer/)
       end
     end
   end
@@ -371,6 +391,7 @@ describe 'the new function' do
       "010" => "Notify[Integer, 8]",
       "0.10" => "Notify[Float, 0.1]",
       "0b10" => "Notify[Integer, 2]",
+      "0"    => "Notify[Integer, 0]",
       false => "Notify[Integer, 0]",
       true => "Notify[Integer, 1]",
     }.each do |input, result|
@@ -518,14 +539,14 @@ describe 'the new function' do
       expect{compile_to_catalog(<<-"MANIFEST"
         $x = Boolean.new('hello')
       MANIFEST
-      )}.to raise_error(Puppet::Error, /cannot be converted to Boolean/)
+      )}.to raise_error(Puppet::Error, /The string 'hello' cannot be converted to Boolean/)
     end
 
     it "does not convert an undef (as may be expected, but is handled as every other undef)" do
       expect{compile_to_catalog(<<-"MANIFEST"
         $x = Boolean.new(undef)
       MANIFEST
-      )}.to raise_error(Puppet::Error, /expects a Boolean value, got Undef/)
+      )}.to raise_error(Puppet::Error, /of type Undef cannot be converted to Boolean/)
     end
   end
 
@@ -546,8 +567,8 @@ describe 'the new function' do
     end
 
     {
-      true          => /cannot be converted to Array/,
-      42.3          => /cannot be converted to Array/,
+      true          => /of type Boolean cannot be converted to Array/,
+      42.3          => /of type Float cannot be converted to Array/,
     }.each do |input, error_match|
       it "errors when given an non convertible #{input.inspect} when wrap is not given" do
         expect{compile_to_catalog(<<-"MANIFEST"
@@ -630,7 +651,7 @@ describe 'the new function' do
       end
     end
 
-    { true             => /cannot be converted to Hash/,
+    { true             => /Value of type Boolean cannot be converted to Hash/,
       [1,2,3]          => /odd number of arguments for Hash/,
     }.each do |input, error_match|
       it "errors when given an non convertible #{input.inspect}" do
@@ -640,6 +661,42 @@ describe 'the new function' do
         )}.to raise_error(Puppet::Error, error_match)
       end
     end
+
+    context 'when using the optional "tree" format' do
+      it 'can convert a tree in flat form to a hash' do
+        expect(compile_to_catalog(<<-"MANIFEST"
+          $x = Hash.new([[[0], a],[[1,0], b],[[1,1], c],[[2,0], d]], tree)
+          notify { test: message => $x }
+        MANIFEST
+        )).to have_resource('Notify[test]').with_parameter(:message, { 0 => 'a', 1 => { 0 => 'b', 1=> 'c'}, 2 => {0 => 'd'} })
+      end
+
+      it 'preserves array in flattened tree but overwrites entries if they are present' do
+        expect(compile_to_catalog(<<-"MANIFEST"
+          $x = Hash.new([[[0], a],[[1,0], b],[[1,1], c],[[2], [overwritten, kept]], [[2,0], d]], tree)
+          notify { test: message => $x }
+        MANIFEST
+        )).to have_resource('Notify[test]').with_parameter(:message, { 0 => 'a', 1 => { 0 => 'b', 1=> 'c'}, 2 => ['d', 'kept'] })
+      end
+
+      it 'preserves hash in flattened tree but overwrites entries if they are present' do
+        expect(compile_to_catalog(<<-"MANIFEST"
+          $x = Hash.new([[[0], a],[[1,0], b],[[1,1], c],[[2], {0 => 0, kept => 1}], [[2,0], d]], tree)
+          notify { test: message => $x }
+        MANIFEST
+  )).to have_resource('Notify[test]').with_parameter(:message, { 0 => 'a', 1 => { 0 => 'b', 1=> 'c'}, 2 => {0=>'d', 'kept'=>1} })
+      end
+    end
+
+    context 'when using the optional "tree_hash" format' do
+      it 'turns array in flattened tree into hash' do
+        expect(compile_to_catalog(<<-"MANIFEST"
+          $x = Hash.new([[[0], a],[[1,0], b],[[1,1], c],[[2], [overwritten, kept]], [[2,0], d]], hash_tree)
+          notify { test: message => $x }
+        MANIFEST
+        )).to have_resource('Notify[test]').with_parameter(:message, { 0=>'a', 1=>{ 0=>'b', 1=>'c'}, 2=>{0=>'d', 1=>'kept'}})
+      end
+    end
   end
 
   context 'when invoked on Struct' do
@@ -658,7 +715,7 @@ describe 'the new function' do
       expect{compile_to_catalog(<<-"MANIFEST"
         $x = Struct[{a => Integer[2]}].new({a => 0})
       MANIFEST
-      )}.to raise_error(Puppet::Error, /entry 'a' expects an Integer\[2, default\]/)
+      )}.to raise_error(Puppet::Error, /entry 'a' expects an Integer\[2\]/)
     end
   end
 
@@ -691,4 +748,14 @@ describe 'the new function' do
       )).to have_resource('Notify[Boolean, true]')
     end
   end
+
+  context 'when invoked on a Type' do
+    it 'creates a Type from its string representation' do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = Type.new('Integer[3,10]')
+        notify { "${type($x)}": }
+      MANIFEST
+      )).to have_resource('Notify[Type[Integer[3, 10]]]')
+    end
+  end
 end

data/spec/unit/functions/next_spec.rb

@@ -88,6 +88,6 @@ describe 'the next function' do
         # line 2
         next()
       CODE
-    end.to raise_error(/next\(\) from context where this is illegal at unknown:3 on node.*/)
+    end.to raise_error(/next\(\) from context where this is illegal \(file: unknown, line: 3\) on node.*/)
   end
 end

data/spec/unit/functions/regsubst_spec.rb

@@ -4,14 +4,13 @@ require 'puppet/loaders'
 
 describe 'the regsubst 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 regsubst(*args)
@@ -30,7 +29,7 @@ describe 'the regsubst function' do
     end
 
     it 'should raise an Error if given a bad flag' do
-      expect { regsubst('foo', 'bar', 'gazonk', 'X') }.to raise_error(/parameter 'flags' expects a match for Pattern\[\/\^\[GEIM\]\*\$\/\], got 'X'/)
+      expect { regsubst('foo', 'bar', 'gazonk', 'X') }.to raise_error(/parameter 'flags' expects an undef value or a match for Pattern\[\/\^\[GEIM\]\*\$\/\], got 'X'/)
     end
 
     it 'should raise an Error if given a bad encoding' do

data/spec/unit/functions/require_spec.rb

@@ -80,4 +80,6 @@ describe 'The "require" function' do
 
   it_should_behave_like 'all functions transforming relative to absolute names', :require
   it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :require
+  it_should_behave_like 'an inclusion function, when --tasks is on,', :require
+
 end

data/spec/unit/functions/return_spec.rb

@@ -90,7 +90,7 @@ describe 'the return function' do
         $result = with(1) |$x| { with($x) |$x| {return(100) }}
         notice $result
       CODE
-    end.to raise_error(/return\(\) from context where this is illegal at unknown:3 on node.*/)
+    end.to raise_error(/return\(\) from context where this is illegal \(file: unknown, line: 3\) on node.*/)
   end
 
   it 'can not be called from top scope' do
@@ -100,6 +100,6 @@ describe 'the return function' do
         # line 2
         return()
       CODE
-    end.to raise_error(/return\(\) from context where this is illegal at unknown:3 on node.*/)
+    end.to raise_error(/return\(\) from context where this is illegal \(file: unknown, line: 3\) on node.*/)
   end
 end

data/spec/unit/functions/round_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the round function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context 'for an integer' do
+    [ 0, 1, -1].each do |x|
+      it "called as round(#{x}) results in the same value" do
+        expect(compile_to_catalog("notify { String( round(#{x}) == #{x}): }")).to have_resource("Notify[true]")
+      end
+    end
+  end
+
+  context 'for a float' do
+    {
+      0.0 => 0,
+      1.1 => 1,
+      -1.1 => -1,
+      2.9 => 3,
+      2.1 => 2,
+      2.49 => 2,
+      2.50 => 3,
+      -2.9 => -3,
+    }.each_pair do |x, expected|
+      it "called as round(#{x}) results in #{expected}" do
+        expect(compile_to_catalog("notify { String( round(#{x}) == #{expected}): }")).to have_resource("Notify[true]")
+      end
+    end
+  end
+
+  [[1,2,3], {'a' => 10}, '"42"'].each do |x|
+    it "errors for a value of class #{x.class}" do
+      expect{ compile_to_catalog("round(#{x})") }.to raise_error(/expects a Numeric value/)
+    end
+  end
+
+end

data/spec/unit/functions/rstrip_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the rstrip function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'removes trailing whitepsace' do
+    expect(compile_to_catalog("notify { String(\" abc\t\n \".rstrip == ' abc'): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns the value if Numeric' do
+    expect(compile_to_catalog("notify { String(42.rstrip == 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 '].rstrip == [' 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.lstrip == ['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']].lstrip")}.to raise_error(/'lstrip' parameter 'arg' expects a value of type Numeric, String, or Iterable/)
+  end
+
+end

data/spec/unit/functions/shared.rb

@@ -83,3 +83,15 @@ shared_examples_for 'an inclusion function, regardless of the type of class refe
     end
 
 end
+
+shared_examples_for 'an inclusion function, when --tasks is on,' do |function|
+  it "is not available when --tasks is on" do
+    Puppet[:tasks] = true
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        #{function}(bar)
+      MANIFEST
+    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+  end
+end
+