puppet 4.7.1-x86-mingw32 → 4.8.0-x86-mingw32

data/spec/unit/functions/logging_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe 'the log function' do
+  include PuppetSpec::Compiler
+
+  def collect_logs(code)
+    Puppet[:code] = code
+    node = Puppet::Node.new('logtest')
+    compiler = Puppet::Parser::Compiler.new(node)
+    node.environment.check_for_reparse
+    logs = []
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      compiler.compile
+    end
+    logs
+  end
+
+  def expect_log(code, log_level, message)
+    logs = collect_logs(code)
+    expect(logs.size).to eql(1)
+    expect(logs[0].level).to eql(log_level)
+    expect(logs[0].message).to eql(message)
+  end
+
+  before(:each) do
+    Puppet[:log_level] = 'debug'
+  end
+
+  Puppet::Util::Log.levels.each do |level|
+    context "for log level '#{level}'" do
+      it 'can be called' do
+        expect_log("#{level.to_s}('yay')", level, 'yay')
+      end
+
+      it 'joins multiple arguments using space' do
+        # Not using the evaluator would result in yay {"a"=>"b", "c"=>"d"}
+        expect_log("#{level.to_s}('a', 'b', 3)", level, 'a b 3')
+      end
+
+      it 'uses the evaluator to format output' do
+        # Not using the evaluator would result in yay {"a"=>"b", "c"=>"d"}
+        expect_log("#{level.to_s}('yay', {a => b, c => d})", level, 'yay {a => b, c => d}')
+      end
+
+      it 'returns undef value' do
+        logs = collect_logs("notice(type(#{level.to_s}('yay')))")
+        expect(logs.size).to eql(2)
+        expect(logs[1].level).to eql(:notice)
+        expect(logs[1].message).to eql('Undef')
+      end
+    end
+  end
+end

data/spec/unit/functions/lookup_spec.rb

@@ -170,7 +170,7 @@ describe "when performing lookup" do
     it 'will not accept a succesful lookup of an undef value when the type rejects it' do
       expect do
         assemble_and_compile('${r}', "'abc::n'", 'String')
-      end.to raise_error(Puppet::ParseError, /Found value had wrong type, expected a String value, got Undef/)
+      end.to raise_error(Puppet::ParseError, /Found value has wrong type, expects a String value, got Undef/)
     end
 
     it 'will raise an exception when value is not found for array key and no default is provided' do
@@ -249,7 +249,7 @@ describe "when performing lookup" do
         expect do
           assemble_and_compile('${r[a]}_${r[b]}', "'abc::x'", 'Hash[String,String]', 'undef', "{'a' => 'dflt_x', 'b' => 32}")
         end.to raise_error(Puppet::ParseError,
-          /Default value had wrong type, entry 'b' expected a String value, got Integer/)
+          /Default value has wrong type, entry 'b' expects a String value, got Integer/)
       end
     end
 
@@ -283,7 +283,7 @@ describe "when performing lookup" do
         expect do
           assemble_and_compile_with_block('${r[a]}_${r[b]}', "{'a' => 'dflt_x', 'b' => 32}", "'abc::x'", 'Hash[String,String]')
         end.to raise_error(Puppet::ParseError,
-          /Value returned from default block had wrong type, entry 'b' expected a String value, got Integer/)
+          /Value returned from default block has wrong type, entry 'b' expects a String value, got Integer/)
       end
 
       it 'receives a single name parameter' do

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, /expected an Integer value, got Undef/)
+    )}.to raise_error(Puppet::Error, /expects an Integer value, got Undef/)
   end
 
   it 'errors if converted value is not assignable to the type' do
@@ -36,7 +36,7 @@ describe 'the new function' do
       $x = Integer[1,5].new('42')
       notify { "one${x}word": }
     MANIFEST
-    )}.to raise_error(Puppet::Error, /expected an Integer\[1, 5\] value, got Integer\[42, 42\]/)
+    )}.to raise_error(Puppet::Error, /expects an Integer\[1, 5\] value, got Integer\[42, 42\]/)
   end
 
   context 'when invoked on NotUndef' do
@@ -90,6 +90,34 @@ describe 'the new function' do
       )).to have_resource('Notify[Integer, 1]')
     end
 
+    it "produces an absolute value when third argument is 'true'" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Integer.new(-42, 10, true))
+      MANIFEST
+      )).to eql(['42'])
+    end
+
+    it "does not produce an absolute value when third argument is 'false'" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Integer.new(-42, 10, false))
+      MANIFEST
+      )).to eql(['-42'])
+    end
+
+    it "produces an absolute value from hash {from => val, abs => true}" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Integer.new({from => -42, abs => true}))
+      MANIFEST
+      )).to eql(['42'])
+    end
+
+    it "does not produce an absolute value from hash {from => val, abs => false}" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Integer.new({from => -42, abs => false}))
+      MANIFEST
+      )).to eql(['-42'])
+    end
+
     context 'when prefixed by a sign' do
       { '+1'     => 1,
         '-1'     => -1,
@@ -362,6 +390,34 @@ describe 'the new function' do
       MANIFEST
       )).to have_resource('Notify[Integer, 42]')
     end
+
+    it "produces an absolute value when second argument is 'true'" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Numeric.new(-42.3, true))
+      MANIFEST
+      )).to eql(['42.3'])
+    end
+
+    it "does not produce an absolute value when second argument is 'false'" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Numeric.new(-42.3, false))
+      MANIFEST
+      )).to eql(['-42.3'])
+    end
+
+    it "produces an absolute value from hash {from => val, abs => true}" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Numeric.new({from => -42.3, abs => true}))
+      MANIFEST
+      )).to eql(['42.3'])
+    end
+
+    it "does not produce an absolute value from hash {from => val, abs => false}" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Numeric.new({from => -42.3, abs => false}))
+      MANIFEST
+      )).to eql(['-42.3'])
+    end
   end
 
   context 'when invoked on Float' do
@@ -397,6 +453,34 @@ describe 'the new function' do
       MANIFEST
       )).to have_resource('Notify[Float, 42.0]')
     end
+
+    it "produces an absolute value when second argument is 'true'" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Float.new(-42.3, true))
+      MANIFEST
+      )).to eql(['42.3'])
+    end
+
+    it "does not produce an absolute value when second argument is 'false'" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Float.new(-42.3, false))
+      MANIFEST
+      )).to eql(['-42.3'])
+    end
+
+    it "produces an absolute value from hash {from => val, abs => true}" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Float.new({from => -42.3, abs => true}))
+      MANIFEST
+      )).to eql(['42.3'])
+    end
+
+    it "does not produce an absolute value from hash {from => val, abs => false}" do
+      expect(eval_and_collect_notices(<<-MANIFEST
+        notice(Float.new({from => -42.3, abs => false}))
+      MANIFEST
+      )).to eql(['-42.3'])
+    end
   end
 
   context 'when invoked on Boolean' do
@@ -441,7 +525,7 @@ describe 'the new function' do
       expect{compile_to_catalog(<<-"MANIFEST"
         $x = Boolean.new(undef)
       MANIFEST
-      )}.to raise_error(Puppet::Error, /expected a Boolean value, got Undef/)
+      )}.to raise_error(Puppet::Error, /expects a Boolean value, got Undef/)
     end
   end
 
@@ -488,6 +572,22 @@ describe 'the new function' do
         )).to have_resource(result)
       end
     end
+
+    it 'produces an array of byte integer values when given a Binary' do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = Array.new(Binary('ABC', '%s'))
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Array[Integer], [65, 66, 67]]')
+    end
+
+    it 'wraps a binary when given extra argument true' do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = Array[Any].new(Binary('ABC', '%s'), true)
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Array[Binary], [QUJD]]')
+    end
   end
 
   context 'when invoked on Tuple' do
@@ -507,7 +607,7 @@ describe 'the new function' do
       expect{compile_to_catalog(<<-"MANIFEST"
         $x = Tuple[Integer,6].new(3)
       MANIFEST
-      )}.to raise_error(Puppet::Error, /expected size to be at least 6, got 3/)
+      )}.to raise_error(Puppet::Error, /expects size to be at least 6, got 3/)
     end
   end
 
@@ -558,7 +658,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' expected an Integer\[2, default\]/)
+      )}.to raise_error(Puppet::Error, /entry 'a' expects an Integer\[2, default\]/)
     end
   end
 

data/spec/unit/functions/next_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the next function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context 'exits a block yielded to iteratively' do
+    it 'with a given value as result for this iteration' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[100, 4, 6]]')
+          $result = String([1,2,3].map |$x| { if $x == 1 { next(100) } $x*2 })
+          notify { $result: }
+        CODE
+    end
+
+    it 'with undef value as result for this iteration when next is not given an argument' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[undef, 4, 6]]')
+          $result = String([1,2,3].map |$x| { if $x == 1 { next() } $x*2 })
+          notify { $result: }
+        CODE
+    end
+  end
+
+  it 'can be called without parentheses around the argument' do
+    expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[100, 4, 6]]')
+        $result = String([1,2,3].map |$x| { if $x == 1 { next 100 } $x*2 })
+        notify { $result: }
+      CODE
+  end
+
+  it 'has the same effect as a return when called from within a block not used in an iteration' do
+    expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[100]')
+        $result = String(with(1) |$x| { if $x == 1 { next(100) } 200 })
+        notify { $result: }
+      CODE
+  end
+
+  it 'has the same effect as a return when called from within a function' do
+    expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[102, 200, 300]]')
+        function do_next() {
+          next(100)
+        }
+        $result = String([1,2,3].map |$x| { if $x == 1 { next do_next()+2 } $x*do_next() })
+        notify { $result: }
+      CODE
+  end
+
+  it 'provides early exit from a class and keeps the class' do
+    expect(eval_and_collect_notices(<<-CODE)).to eql(['a', 'c', 'true', 'true'])
+        class notices_c { notice 'c' }
+        class does_next {
+          notice 'a'
+          if 1 == 1 { next() } # avoid making next line statically unreachable
+          notice 'b'
+        }
+        # include two classes to check that next does not do an early return from
+        # the include function.
+        include(does_next, notices_c)
+        notice defined(does_next)
+        notice defined(notices_c)
+      CODE
+  end
+
+  it 'provides early exit from a user defined resource and keeps the resource' do
+    expect(eval_and_collect_notices(<<-CODE)).to eql(['the_doer_of_next', 'copy_cat', 'true', 'true'])
+        define does_next {
+          notice $title
+          if 1 == 1 { next() } # avoid making next line statically unreachable
+          notice 'b'
+        }
+        define checker {
+          notice defined(Does_next['the_doer_of_next'])
+          notice defined(Does_next['copy_cat'])
+        }
+        # create two instances to ensure next does not break the entire
+        # resource expression
+        does_next { ['the_doer_of_next', 'copy_cat']: }
+        checker { 'needed_because_evaluation_order': }
+      CODE
+  end
+
+  it 'can not be called from top scope' do
+    expect do
+      compile_to_catalog(<<-CODE)
+        # line 1
+        # line 2
+        next()
+      CODE
+    end.to raise_error(/next\(\) from context where this is illegal at unknown:3 on node.*/)
+  end
+end

data/spec/unit/functions/require_spec.rb

@@ -0,0 +1,83 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'puppet/parser/functions'
+require 'matchers/containment_matchers'
+require 'matchers/resource'
+require 'matchers/include_in_order'
+require 'unit/functions/shared'
+
+
+describe 'The "require" function' do
+  include PuppetSpec::Compiler
+  include ContainmentMatchers
+  include Matchers::Resource
+
+  before(:each) do
+    compiler  = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
+    @scope = compiler.topscope
+  end
+
+  it 'includes a class that is not already included' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class required {
+        notify { "required": }
+      }
+      require required
+    MANIFEST
+
+    expect(catalog.classes).to include("required")
+  end
+
+  it 'sets the require attribute on the requiring resource' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class required {
+        notify { "required": }
+      }
+      class requiring {
+        require required
+      }
+      include requiring
+    MANIFEST
+
+    requiring = catalog.resource("Class", "requiring")
+    expect(requiring["require"]).to be_instance_of(Array)
+    expect(requiring["require"][0]).to be_instance_of(Puppet::Resource)
+    expect(requiring["require"][0].to_s).to eql("Class[Required]")
+  end
+
+  it 'appends to the require attribute on the requiring resource if it already has requirements' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+
+      class required { }
+      class also_required { }
+
+      class requiring {
+        require required
+        require also_required
+      }
+      include requiring
+    MANIFEST
+
+    requiring = catalog.resource("Class", "requiring")
+    expect(requiring["require"]).to be_instance_of(Array)
+    expect(requiring["require"][0]).to be_instance_of(Puppet::Resource)
+    expect(requiring["require"][0].to_s).to eql("Class[Required]")
+    expect(requiring["require"][1]).to be_instance_of(Puppet::Resource)
+    expect(requiring["require"][1].to_s).to eql("Class[Also_required]")
+  end
+
+  it "includes the class when using a fully qualified anchored name" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class required {
+        notify { "required": }
+      }
+      require ::required
+    MANIFEST
+
+    expect(catalog.classes).to include("required")
+  end
+
+  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
+end

data/spec/unit/functions/return_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the return function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context 'returns from outer function when called from nested block' do
+    it 'with a given value as function result' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[100]')
+          function please_return() {
+            [1,2,3].map |$x| { if $x == 1 { return(100) } 200 }
+            300
+          }
+          notify { String(please_return()): }
+        CODE
+    end
+
+    it 'with undef value as function result when not given an argument' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[xy]')
+          function please_return() {
+            [1,2,3].map |$x| { if $x == 1 { return() } 200 }
+            300
+          }
+          notify { "x${please_return}y": }
+        CODE
+    end
+  end
+
+  it 'can be called without parentheses around the argument' do
+    expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[100]')
+        function please_return() {
+          if 1 == 1 { return 100 }
+          200
+        }
+        notify { String(please_return()): }
+      CODE
+  end
+
+  it 'provides early exit from a class and keeps the class' do
+    expect(eval_and_collect_notices(<<-CODE)).to eql(['a', 'c', 'true', 'true'])
+        class notices_c { notice 'c' }
+        class does_next {
+          notice 'a'
+          if 1 == 1 { return() } # avoid making next line statically unreachable
+          notice 'b'
+        }
+        # include two classes to check that next does not do an early return from
+        # the include function.
+        include(does_next, notices_c)
+        notice defined(does_next)
+        notice defined(notices_c)
+      CODE
+  end
+
+  it 'provides early exit from a user defined resource and keeps the resource' do
+    expect(eval_and_collect_notices(<<-CODE)).to eql(['the_doer_of_next', 'copy_cat', 'true', 'true'])
+        define does_next {
+          notice $title
+          if 1 == 1 { return() } # avoid making next line statically unreachable
+          notice 'b'
+        }
+        define checker {
+          notice defined(Does_next['the_doer_of_next'])
+          notice defined(Does_next['copy_cat'])
+        }
+        # create two instances to ensure next does not break the entire
+        # resource expression
+        does_next { ['the_doer_of_next', 'copy_cat']: }
+        checker { 'needed_because_evaluation_order': }
+      CODE
+  end
+
+  it 'can be called when nested in a function to make that function return' do
+    expect(eval_and_collect_notices(<<-CODE)).to eql(['100'])
+      function nested_return() {
+        with(1) |$x| { with($x) |$x| {return(100) }}
+      }
+      notice nested_return()
+      CODE
+  end
+
+  it 'can not be called nested from top scope' do
+    expect do
+      compile_to_catalog(<<-CODE)
+        # line 1
+        # line 2
+        $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
+
+  it 'can not be called from top scope' do
+    expect do
+      compile_to_catalog(<<-CODE)
+        # line 1
+        # line 2
+        return()
+      CODE
+    end.to raise_error(/return\(\) from context where this is illegal at unknown:3 on node.*/)
+  end
+end