puppet 3.6.2 → 3.7.0

data/spec/unit/functions/assert_type_spec.rb

@@ -37,8 +37,8 @@ describe 'the assert_type function' do
     end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
 "function 'assert_type' called with mis-matched arguments
 expected one of:
-  assert_type(Type type, Optional[Object] value) - arg count {2}
-  assert_type(String type_string, Optional[Object] value) - arg count {2}
+  assert_type(Type type, Any value, Callable[Type, Type] block {0,1}) - arg count {2,3}
+  assert_type(String type_string, Any value, Callable[Type, Type] block {0,1}) - arg count {2,3}
 actual:
   assert_type(Integer, Integer) - arg count {2}")))
   end
@@ -46,7 +46,13 @@ actual:
   it 'allows the second arg to be undef/nil)' do
     expect do
       func.call({}, optional(String), nil)
-    end.to_not raise_error(ArgumentError)
+    end.to_not raise_error
+  end
+
+  it 'can be called with a callable that receives a specific type' do
+    expected, actual = func.call({}, optional(String), 1, create_callable_2_args_unit)
+    expect(expected.to_s).to eql('Optional[String]')
+    expect(actual.to_s).to eql('Integer[1, 1]')
   end
 
   def optional(type_ref)
@@ -56,4 +62,17 @@ actual:
   def type(type_ref)
     Puppet::Pops::Types::TypeFactory.type_of(type_ref)
   end
+
+  def create_callable_2_args_unit()
+    Puppet::Functions.create_function(:func) do
+      dispatch :func do
+        param 'Type', 'expected'
+        param 'Type', 'actual'
+      end
+
+      def func(expected, actual)
+        [expected, actual]
+      end
+    end.new({}, nil)
+  end
 end

data/spec/unit/{parser/methods → functions}/each_spec.rb

@@ -1,7 +1,8 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
-require 'rubygems'
+
+require 'shared_behaviours/iterative_functions'
 
 describe 'the each method' do
   include PuppetSpec::Compiler
@@ -23,6 +24,7 @@ describe 'the each method' do
       catalog.resource(:file, "/file_2")['ensure'].should == 'present'
       catalog.resource(:file, "/file_3")['ensure'].should == 'present'
     end
+
     it 'each on an array selecting each value - function call style' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
@@ -61,6 +63,7 @@ describe 'the each method' do
       catalog.resource(:file, "/file_b")['ensure'].should == 'absent'
       catalog.resource(:file, "/file_c")['ensure'].should == 'present'
     end
+
     it 'each on a hash selecting key and value' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {'a'=>present,'b'=>absent,'c'=>present}
@@ -73,7 +76,21 @@ describe 'the each method' do
       catalog.resource(:file, "/file_b")['ensure'].should == 'absent'
       catalog.resource(:file, "/file_c")['ensure'].should == 'present'
     end
+
+    it 'each on a hash selecting key and value (using captures-last parameter)' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>present,'b'=>absent,'c'=>present}
+        $a.each |*$kv| {
+          file { "/file_${kv[0]}": ensure => $kv[1] }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_a")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_b")['ensure'].should == 'absent'
+      catalog.resource(:file, "/file_c")['ensure'].should == 'present'
+    end
   end
+
   context "should produce receiver" do
     it 'each checking produced value using single expression' do
       catalog = compile_to_catalog(<<-MANIFEST)
@@ -88,4 +105,7 @@ describe 'the each method' do
     end
 
   end
+  it_should_behave_like 'all iterative functions argument checks', 'each'
+  it_should_behave_like 'all iterative functions hash handling', 'each'
+
 end

data/spec/unit/{parser/functions → functions}/epp_spec.rb

@@ -27,7 +27,7 @@ describe "the epp function" do
     end
 
     it "get nil accessing a variable that is undef" do
-      scope['undef_var'] = :undef
+      scope['undef_var'] = nil
       eval_template("<%= $undef_var == undef %>").should == "true"
     end
 
@@ -36,26 +36,74 @@ describe "the epp function" do
       eval_template_with_args("<%= $phantom == dragos %>", 'phantom' => 'dragos').should == "true"
     end
 
+    it "can use values from the enclosing scope for defaults" do
+      scope['phantom'] = 'of the opera'
+      eval_template("<%- |$phantom = $phantom| -%><%= $phantom %>").should == "of the opera"
+    end
+
+    it "uses the default value if the given value is undef/nil" do
+      eval_template_with_args("<%- |$phantom = 'inside your mind'| -%><%= $phantom %>", 'phantom' => nil).should == "inside your mind"
+    end
+
     it "gets shadowed variable if args are given and parameters are specified" do
       scope['x'] = 'wrong one'
-      eval_template_with_args("<%-( $x )-%><%= $x == correct %>", 'x' => 'correct').should == "true"
+      eval_template_with_args("<%- |$x| -%><%= $x == correct %>", 'x' => 'correct').should == "true"
     end
 
     it "raises an error if required variable is not given" do
       scope['x'] = 'wrong one'
-      expect {
+      expect do
         eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'y' => 'correct')
-      }.to raise_error(/no value given for required parameters x/)
+      end.to raise_error(/no value given for required parameters x/)
     end
 
     it "raises an error if too many arguments are given" do
       scope['x'] = 'wrong one'
-      expect {
+      expect do
         eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct', 'y' => 'surplus')
-      }.to raise_error(/Too many arguments: 2 for 1/)
+      end.to raise_error(/Too many arguments: 2 for 1/)
+    end
+  end
+
+  context "when given an empty template" do
+     it "allows the template file to be empty" do
+       expect(eval_template("")).to eq("")
+     end
+
+    it "allows the template to have empty body after parameters" do
+      expect(eval_template_with_args("<%-|$x|%>", 'x'=>1)).to eq("")
     end
   end
 
+  context "when using typed parameters" do
+    it "allows a passed value that matches the parameter's type" do
+      expect(eval_template_with_args("<%-|String $x|-%><%= $x == correct %>", 'x' => 'correct')).to eq("true")
+    end
+
+    it "does not allow slurped parameters" do
+      expect do
+        eval_template_with_args("<%-|*$x|-%><%= $x %>", 'x' => 'incorrect')
+      end.to raise_error(/'captures rest' - not supported in an Epp Template/)
+    end
+
+    it "raises an error when the passed value does not match the parameter's type" do
+      expect do
+        eval_template_with_args("<%-|Integer $x|-%><%= $x %>", 'x' => 'incorrect')
+      end.to raise_error(/expected.*Integer.*actual.*String/m)
+    end
+
+    it "raises an error when the default value does not match the parameter's type" do
+      expect do
+        eval_template("<%-|Integer $x = 'nope'|-%><%= $x %>")
+      end.to raise_error(/expected.*Integer.*actual.*String/m)
+    end
+
+    it "allows an parameter to default to undef" do
+      expect(eval_template("<%-|Optional[Integer] $x = undef|-%><%= $x == undef %>")).to eq("true")
+    end
+  end
+
+
   # although never a problem with epp
   it "is not interfered with by having a variable named 'string' (#14093)" do
     scope['string'] = "this output should not be seen"
@@ -78,7 +126,7 @@ describe "the epp function" do
         }})
       Puppet.override({:current_environment => (env = Puppet::Node::Environment.create(:testload, [ modules_dir ]))}, "test") do
         node.environment = env
-        expect(scope.function_epp([ 'testmodule/the_x.epp', { 'x' => '3'} ])).to eql("The x is 3")
+        expect(epp_function.call(scope, 'testmodule/the_x.epp', { 'x' => '3'} )).to eql("The x is 3")
       end
     end
   end
@@ -89,7 +137,7 @@ describe "the epp function" do
     File.open(filename, "w+") { |f| f.write(content) }
 
     Puppet::Parser::Files.stubs(:find_template).returns(filename)
-    scope.function_epp(['template', args_hash])
+    epp_function.call(scope, 'template', args_hash)
   end
 
   def eval_template(content)
@@ -98,6 +146,10 @@ describe "the epp function" do
     File.open(filename, "w+") { |f| f.write(content) }
 
     Puppet::Parser::Files.stubs(:find_template).returns(filename)
-    scope.function_epp(['template'])
+    epp_function.call(scope, 'template')
+  end
+
+  def epp_function()
+    epp_func = scope.compiler.loaders.public_environment_loader.load(:function, 'epp')
   end
 end

data/spec/unit/{parser/methods → functions}/filter_spec.rb

@@ -1,11 +1,13 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
+require 'matchers/resource'
 
-require 'unit/parser/methods/shared'
+require 'shared_behaviours/iterative_functions'
 
 describe 'the filter method' do
   include PuppetSpec::Compiler
+  include Matchers::Resource
 
   before :each do
     Puppet[:parser] = 'future'
@@ -19,8 +21,8 @@ describe 'the filter method' do
       }
     MANIFEST
 
-    catalog.resource(:file, "/file_strawberry")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_blueberry")['ensure'].should == 'present'
+    expect(catalog).to have_resource("File[/file_strawberry]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_blueberry]").with_parameter(:ensure, 'present')
   end
 
   it 'should filter on enumerable type (Integer)' do
@@ -31,9 +33,9 @@ describe 'the filter method' do
       }
     MANIFEST
 
-    catalog.resource(:file, "/file_3")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_6")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_9")['ensure'].should == 'present'
+    expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_9]").with_parameter(:ensure, 'present')
   end
 
   it 'should filter on enumerable type (Integer) using two args index/value' do
@@ -44,9 +46,9 @@ describe 'the filter method' do
       }
     MANIFEST
 
-    catalog.resource(:file, "/file_10")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_13")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_16")['ensure'].should == 'present'
+    expect(catalog).to have_resource("File[/file_10]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_13]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_16]").with_parameter(:ensure, 'present')
   end
 
   it 'should produce an array when acting on an array' do
@@ -57,8 +59,8 @@ describe 'the filter method' do
       file { "/file_${b[1]}": ensure => present }
     MANIFEST
 
-    catalog.resource(:file, "/file_strawberry")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_blueberry")['ensure'].should == 'present'
+    expect(catalog).to have_resource("File[/file_strawberry]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_blueberry]").with_parameter(:ensure, 'present')
   end
 
   it 'can filter array using index and value' do
@@ -69,8 +71,20 @@ describe 'the filter method' do
       file { "/file_${b[1]}": ensure => present }
     MANIFEST
 
-    catalog.resource(:file, "/file_strawberry")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_orange")['ensure'].should == 'present'
+    expect(catalog).to have_resource("File[/file_strawberry]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_orange]").with_parameter(:ensure, 'present')
+  end
+
+  it 'can filter array using index and value (using captures-rest)' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = ['strawberry','blueberry','orange']
+      $b = $a.filter |*$ix|{ $ix[0]  == 0 or $ix[0] ==2}
+      file { "/file_${b[0]}": ensure => present }
+      file { "/file_${b[1]}": ensure => present }
+    MANIFEST
+
+    expect(catalog).to have_resource("File[/file_strawberry]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_orange]").with_parameter(:ensure, 'present')
   end
 
   it 'filters on a hash (all berries) by key' do
@@ -81,8 +95,8 @@ describe 'the filter method' do
       }
     MANIFEST
 
-    catalog.resource(:file, "/file_strawberry")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_blueberry")['ensure'].should == 'present'
+    expect(catalog).to have_resource("File[/file_strawberry]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_blueberry]").with_parameter(:ensure, 'present')
   end
 
   it 'should produce a hash when acting on a hash' do
@@ -95,9 +109,9 @@ describe 'the filter method' do
 
     MANIFEST
 
-    catalog.resource(:file, "/file_red")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_blue")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_")['ensure'].should == 'present'
+    expect(catalog).to have_resource("File[/file_red]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_blue]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_]").with_parameter(:ensure, 'present')
   end
 
   it 'filters on a hash (all berries) by value' do
@@ -108,26 +122,8 @@ describe 'the filter method' do
       }
     MANIFEST
 
-    catalog.resource(:file, "/file_strawb")['ensure'].should == 'present'
-    catalog.resource(:file, "/file_blueb")['ensure'].should == 'present'
-  end
-
-  context 'filter checks arguments and' do
-    it 'raises an error when block has more than 2 argument' do
-      expect do
-        compile_to_catalog(<<-MANIFEST)
-          [1].filter |$indexm, $x, $yikes|{  }
-        MANIFEST
-      end.to raise_error(Puppet::Error, /block must define at most two parameters/)
-    end
-
-    it 'raises an error when block has fewer than 1 argument' do
-      expect do
-        compile_to_catalog(<<-MANIFEST)
-          [1].filter || {  }
-        MANIFEST
-      end.to raise_error(Puppet::Error, /block must define at least one parameter/)
-    end
+    expect(catalog).to have_resource("File[/file_strawb]").with_parameter(:ensure, 'present')
+    expect(catalog).to have_resource("File[/file_blueb]").with_parameter(:ensure, 'present')
   end
 
   it_should_behave_like 'all iterative functions argument checks', 'filter'

data/spec/unit/{parser/functions → functions}/inline_epp_spec.rb

@@ -56,8 +56,18 @@ describe "the inline_epp function" do
     end
   end
 
+  context "when given an empty template" do
+     it "allows the template file to be empty" do
+       expect(eval_template("")).to eq("")
+     end
+
+    it "allows the template to have empty body after parameters" do
+      expect(eval_template_with_args("<%-|$x|%>", 'x'=>1)).to eq("")
+    end
+  end
+
   it "renders a block expression" do
-    eval_template_with_args("<%= {($x) $x + 1} %>", 'x' => 2).should == "3"
+    eval_template_with_args("<%= { $y = $x $x + 1} %>", 'x' => 2).should == "3"
   end
 
   # although never a problem with epp
@@ -73,10 +83,15 @@ describe "the inline_epp function" do
 
 
   def eval_template_with_args(content, args_hash)
-    scope.function_inline_epp([content, args_hash])
+    epp_function.call(scope, content, args_hash)
   end
 
   def eval_template(content)
-    scope.function_inline_epp([content])
+    epp_function.call(scope, content)
   end
+
+  def epp_function()
+    epp_func = scope.compiler.loaders.public_environment_loader.load(:function, 'inline_epp')
+  end
+
 end

data/spec/unit/functions/map_spec.rb

@@ -0,0 +1,169 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+require 'shared_behaviours/iterative_functions'
+
+describe 'the map method' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  before :each do
+    Puppet[:parser] = "future"
+  end
+
+  context "using future parser" do
+    it 'map on an array (multiplying each value by 2)' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $a.map |$x|{ $x*2}.each |$v|{
+          file { "/file_$v": ensure => present }
+        }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_4]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
+    end
+
+    it 'map on an enumerable type (multiplying each value by 2)' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = Integer[1,3]
+        $a.map |$x|{ $x*2}.each |$v|{
+          file { "/file_$v": ensure => present }
+        }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_4]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
+    end
+
+    it 'map on an integer (multiply each by 3)' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        3.map |$x|{ $x*3}.each |$v|{
+          file { "/file_$v": ensure => present }
+        }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_0]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
+    end
+
+    it 'map on a string' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {a=>x, b=>y}
+        "ab".map |$x|{$a[$x]}.each |$v|{
+          file { "/file_$v": ensure => present }
+        }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_x]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_y]").with_parameter(:ensure, 'present')
+    end
+
+    it 'map on an array (multiplying value by 10 in even index position)' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $a.map |$i, $x|{ if $i % 2 == 0 {$x} else {$x*10}}.each |$v|{
+          file { "/file_$v": ensure => present }
+        }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_20]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
+    end
+
+    it 'map on a hash selecting keys' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'a'=>1,'b'=>2,'c'=>3}
+      $a.map |$x|{ $x[0]}.each |$k|{
+          file { "/file_$k": ensure => present }
+        }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_a]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_b]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_c]").with_parameter(:ensure, 'present')
+    end
+
+    it 'map on a hash selecting keys - using two block parameters' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'a'=>1,'b'=>2,'c'=>3}
+      $a.map |$k,$v|{ file { "/file_$k": ensure => present }
+        }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_a]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_b]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_c]").with_parameter(:ensure, 'present')
+    end
+
+    it 'map on a hash using captures-last parameter' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'a'=>present,'b'=>absent,'c'=>present}
+      $a.map |*$kv|{ file { "/file_${kv[0]}": ensure => $kv[1] } }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_a]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_b]").with_parameter(:ensure, 'absent')
+      expect(catalog).to have_resource("File[/file_c]").with_parameter(:ensure, 'present')
+    end
+
+    it 'each on a hash selecting value' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'a'=>1,'b'=>2,'c'=>3}
+      $a.map |$x|{ $x[1]}.each |$k|{ file { "/file_$k": ensure => present } }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
+    end
+
+    it 'each on a hash selecting value - using two block parameters' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'a'=>1,'b'=>2,'c'=>3}
+      $a.map |$k,$v|{ file { "/file_$v": ensure => present } }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
+    end
+
+    context "handles data type corner cases" do
+      it "map gets values that are false" do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          $a = [false,false]
+          $a.map |$x| { $x }.each |$i, $v| {
+            file { "/file_$i.$v": ensure => present }
+          }
+        MANIFEST
+
+        expect(catalog).to have_resource("File[/file_0.false]").with_parameter(:ensure, 'present')
+        expect(catalog).to have_resource("File[/file_1.false]").with_parameter(:ensure, 'present')
+      end
+
+      it "map gets values that are nil" do
+        Puppet::Parser::Functions.newfunction(:nil_array, :type => :rvalue) do |args|
+          [nil]
+        end
+        catalog = compile_to_catalog(<<-MANIFEST)
+          $a = nil_array()
+          $a.map |$x| { $x }.each |$i, $v| {
+            file { "/file_$i.$v": ensure => present }
+          }
+        MANIFEST
+
+        expect(catalog).to have_resource("File[/file_0.]").with_parameter(:ensure, 'present')
+      end
+    end
+
+  it_should_behave_like 'all iterative functions argument checks', 'map'
+  it_should_behave_like 'all iterative functions hash handling', 'map'
+  end
+end