puppet 3.1.1 → 3.2.0.rc1

data/spec/unit/parser/methods/reduce_spec.rb

@@ -0,0 +1,67 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe 'the reduce method' do
+  include PuppetSpec::Compiler
+
+  before :all do
+    # enable switching back 
+    @saved_parser = Puppet[:parser]
+    # These tests only work with future parser
+  end
+  after :all do
+    # switch back to original 
+    Puppet[:parser] = @saved_parser
+  end
+
+  before :each do
+    node      = Puppet::Node.new("floppy", :environment => 'production')
+    @compiler = Puppet::Parser::Compiler.new(node)
+    @scope    = Puppet::Parser::Scope.new(@compiler)
+    @topscope = @scope.compiler.topscope
+    @scope.parent = @topscope
+    Puppet[:parser] = 'future'
+  end
+
+  context "should be callable as" do
+    it 'reduce on an array' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $b = $a.reduce {|$memo, $x| $memo + $x }
+        file { "/file_$b": ensure => present }
+      MANIFEST
+
+      catalog.resource(:file, "/file_6")['ensure'].should == 'present'
+    end    
+    it 'reduce on an array with start value' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $b = $a.reduce(4) {|$memo, $x| $memo + $x }
+        file { "/file_$b": ensure => present }
+      MANIFEST
+  
+      catalog.resource(:file, "/file_10")['ensure'].should == 'present'
+    end    
+    it 'reduce on a hash' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {a=>1, b=>2, c=>3}
+        $start = [ignored, 4]
+        $b = $a.reduce {|$memo, $x| ['sum', $memo[1] + $x[1]] }
+        file { "/file_${$b[0]}_${$b[1]}": ensure => present }
+      MANIFEST
+    
+      catalog.resource(:file, "/file_sum_6")['ensure'].should == 'present'
+    end    
+    it 'reduce on a hash with start value' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {a=>1, b=>2, c=>3}
+        $start = ['ignored', 4]
+        $b = $a.reduce($start) {|$memo, $x| ['sum', $memo[1] + $x[1]] }
+        file { "/file_${$b[0]}_${$b[1]}": ensure => present }
+      MANIFEST
+  
+      catalog.resource(:file, "/file_sum_10")['ensure'].should == 'present'
+    end    
+  end
+end

data/spec/unit/parser/methods/reject_spec.rb

@@ -0,0 +1,73 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+require 'unit/parser/methods/shared'
+
+describe 'the reject method' do
+  include PuppetSpec::Compiler
+
+  before :each do
+    Puppet[:parser] = 'future'
+  end
+
+  it 'rejects on an array (no berries)' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = ['strawberry','blueberry','orange']
+      $a.reject {|$x| $x  =~ /berry$/}.foreach {|$v|
+        file { "/file_$v": ensure => present }
+      }
+    MANIFEST
+
+    catalog.resource(:file, "/file_orange")['ensure'].should == 'present'
+    catalog.resource(:file, "/file_strawberry").should == nil
+  end
+
+  it 'produces an array when acting on an array' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = ['strawberry','blueberry','orange']
+      $b = $a.reject {|$x| $x  =~ /berry$/}
+      file { "/file_${b[0]}": ensure => present }
+
+    MANIFEST
+
+    catalog.resource(:file, "/file_orange")['ensure'].should == 'present'
+    catalog.resource(:file, "/file_strawberry").should == nil
+  end
+
+  it 'rejects on a hash (all berries) by key' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'strawberry'=>'red','blueberry'=>'blue','orange'=>'orange'}
+      $a.reject {|$x| $x[0]  =~ /berry$/}.foreach {|$v|
+        file { "/file_${v[0]}": ensure => present }
+      }
+    MANIFEST
+
+    catalog.resource(:file, "/file_orange")['ensure'].should == 'present'
+  end
+
+  it 'produces a hash when acting on a hash' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'strawberry'=>'red','blueberry'=>'blue','grape'=>'purple'}
+      $b = $a.reject {|$x| $x[0]  =~ /berry$/}
+      file { "/file_${b[grape]}": ensure => present }
+
+    MANIFEST
+
+    catalog.resource(:file, "/file_purple")['ensure'].should == 'present'
+  end
+
+  it 'rejects on a hash (all berries) by value' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'strawb'=>'red berry','blueb'=>'blue berry','orange'=>'orange fruit'}
+      $a.reject {|$x| $x[1]  =~ /berry$/}.foreach {|$v|
+        file { "/file_${v[0]}": ensure => present }
+      }
+    MANIFEST
+
+    catalog.resource(:file, "/file_orange")['ensure'].should == 'present'
+  end
+
+  it_should_behave_like 'all iterative functions argument checks', 'reject'
+  it_should_behave_like 'all iterative functions hash handling', 'reject'
+end

data/spec/unit/parser/methods/select_spec.rb

@@ -0,0 +1,79 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+require 'unit/parser/methods/shared'
+
+describe 'the select method' do
+  include PuppetSpec::Compiler
+
+  before :each do
+    Puppet[:parser] = 'future'
+  end
+
+  it 'should select on an array (all berries)' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = ['strawberry','blueberry','orange']
+      $a.select {|$x| $x  =~ /berry$/}.foreach {|$v|
+        file { "/file_$v": ensure => present }
+      }
+    MANIFEST
+
+    catalog.resource(:file, "/file_strawberry")['ensure'].should == 'present'
+    catalog.resource(:file, "/file_blueberry")['ensure'].should == 'present'
+  end
+
+  it 'should produce an array when acting on an array' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = ['strawberry','blueberry','orange']
+      $b = $a.select {|$x| $x  =~ /berry$/}
+      file { "/file_${b[0]}": ensure => present }
+      file { "/file_${b[1]}": ensure => present }
+    MANIFEST
+
+    catalog.resource(:file, "/file_strawberry")['ensure'].should == 'present'
+    catalog.resource(:file, "/file_blueberry")['ensure'].should == 'present'
+  end
+
+  it 'selects on a hash (all berries) by key' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'strawberry'=>'red','blueberry'=>'blue','orange'=>'orange'}
+      $a.select {|$x| $x[0]  =~ /berry$/}.foreach {|$v|
+        file { "/file_${v[0]}": ensure => present }
+      }
+    MANIFEST
+
+    catalog.resource(:file, "/file_strawberry")['ensure'].should == 'present'
+    catalog.resource(:file, "/file_blueberry")['ensure'].should == 'present'
+  end
+
+  it 'should produce a hash when acting on a hash' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'strawberry'=>'red','blueberry'=>'blue','orange'=>'orange'}
+      $b = $a.select {|$x| $x[0]  =~ /berry$/}
+      file { "/file_${b['strawberry']}": ensure => present }
+      file { "/file_${b['blueberry']}": ensure => present }
+      file { "/file_${b['orange']}": ensure => present }
+
+    MANIFEST
+
+    catalog.resource(:file, "/file_red")['ensure'].should == 'present'
+    catalog.resource(:file, "/file_blue")['ensure'].should == 'present'
+    catalog.resource(:file, "/file_")['ensure'].should == 'present'
+  end
+
+  it 'selects on a hash (all berries) by value' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'strawb'=>'red berry','blueb'=>'blue berry','orange'=>'orange fruit'}
+      $a.select {|$x| $x[1]  =~ /berry$/}.foreach {|$v|
+        file { "/file_${v[0]}": ensure => present }
+      }
+    MANIFEST
+
+    catalog.resource(:file, "/file_strawb")['ensure'].should == 'present'
+    catalog.resource(:file, "/file_blueb")['ensure'].should == 'present'
+  end
+
+  it_should_behave_like 'all iterative functions argument checks', 'select'
+  it_should_behave_like 'all iterative functions hash handling', 'select'
+end

data/spec/unit/parser/methods/shared.rb

@@ -0,0 +1,61 @@
+
+shared_examples_for 'all iterative functions hash handling' do |func|
+  it 'passes a hash entry as an array of the key and value' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      {a=>1}.#{func} { |$v| notify { "${v[0]} ${v[1]}": } }
+    MANIFEST
+
+    catalog.resource(:notify, "a 1").should_not be_nil
+  end
+end
+
+shared_examples_for 'all iterative functions argument checks' do |func|
+
+  it 'raises an error when defined with more than 1 argument' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func} { |$x, $yikes| }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /Too few arguments/)
+  end
+
+  it 'raises an error when defined with fewer than 1 argument' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func} { || }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /Too many arguments/)
+  end
+
+  it 'raises an error when used against an unsupported type' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        "not correct".#{func} { |$v| }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /must be an Array or a Hash/)
+  end
+
+  it 'raises an error when called with any parameters besides a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func}(1) { |$v| }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /Wrong number of arguments/)
+  end
+
+  it 'raises an error when called without a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func}()
+      MANIFEST
+    end.to raise_error(Puppet::Error, /Wrong number of arguments/)
+  end
+
+  it 'raises an error when called without a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func}(1)
+      MANIFEST
+    end.to raise_error(Puppet::Error, /must be a parameterized block/)
+  end
+end

data/spec/unit/parser/methods/slice_spec.rb

@@ -0,0 +1,97 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'rubygems'
+
+describe 'methods' do
+  include PuppetSpec::Compiler
+
+  before :all do
+    # enable switching back 
+    @saved_parser = Puppet[:parser]
+    # These tests only work with future parser
+    Puppet[:parser] = 'future'
+  end
+  after :all do
+    # switch back to original 
+    Puppet[:parser] = @saved_parser
+  end
+
+  before :each do
+    node      = Puppet::Node.new("floppy", :environment => 'production')
+    @compiler = Puppet::Parser::Compiler.new(node)
+    @scope    = Puppet::Parser::Scope.new(@compiler)
+    @topscope = @scope.compiler.topscope
+    @scope.parent = @topscope
+    Puppet[:parser] = 'future'
+  end
+
+  context "should be callable on array as" do
+    
+    it 'slice with explicit parameters' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1, present, 2, absent, 3, present]
+        $a.slice(2) |$k,$v| { 
+          file { "/file_${$k}": ensure => $v }
+        }
+      MANIFEST
+  
+      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_2")['ensure'].should == 'absent'
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+    end
+    it 'slice with one parameter' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1, present, 2, absent, 3, present]
+        $a.slice(2) |$k| { 
+          file { "/file_${$k[0]}": ensure => $k[1] }
+        }
+      MANIFEST
+  
+      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_2")['ensure'].should == 'absent'
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+    end
+    it 'slice with shorter last slice' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1, present, 2, present, 3, absent]
+        $a.slice(4) |$a, $b, $c, $d| { 
+          file { "/file_$a.$c": ensure => $b }
+        }
+      MANIFEST
+    
+      catalog.resource(:file, "/file_1.2")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_3.")['ensure'].should == 'absent'
+    end
+  end
+  context "should be callable on hash as" do
+    
+    it 'slice with explicit parameters, missing are empty' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {1=>present, 2=>present, 3=>absent}
+        $a.slice(2) |$a,$b| { 
+          file { "/file_${a[0]}.${b[0]}": ensure => $a[1] }
+        }
+      MANIFEST
+  
+      catalog.resource(:file, "/file_1.2")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_3.")['ensure'].should == 'absent'
+    end
+  
+  end
+  context "when called without a block" do
+    it "should produce an array with the result" do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1, present, 2, absent, 3, present]
+        $a.slice(2).each |$k| { 
+          file { "/file_${$k[0]}": ensure => $k[1] }
+        }
+      MANIFEST
+  
+      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_2")['ensure'].should == 'absent'
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+
+    end
+  end
+end

data/spec/unit/parser/parser_spec.rb

@@ -100,11 +100,11 @@ describe Puppet::Parser do
       Puppet::Parser::AST::Not.expects(:new).with { |h| h[:value].is_a?(Puppet::Parser::AST::Boolean) }
       @parser.parse("unless false { $var = 1 }")
     end
-    
+
     it "should not raise an error with empty statements" do
       expect { @parser.parse("unless false { }") }.to_not raise_error
     end
-    
+
     #test for bug #13296
     it "should not override 'unless' as a parameter inside resources" do
       lambda { @parser.parse("exec {'/bin/echo foo': unless => '/usr/bin/false',}") }.should_not raise_error

data/spec/unit/parser/scope_spec.rb

@@ -84,32 +84,34 @@ describe Puppet::Parser::Scope do
   end
 
   describe "when custom functions are called" do
-    before :each do
-      @env      = Puppet::Node::Environment.new('testing')
-      @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new('foo', :environment => @env))
-      @scope    = Puppet::Parser::Scope.new(@compiler)
-    end
+    let(:env) { Puppet::Node::Environment.new('testing') }
+    let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new('foo', :environment => env)) }
+    let(:scope) { Puppet::Parser::Scope.new(compiler) }
 
-    it "should load and call the method if it looks like a function and it exists" do
-      @scope.function_sprintf(["%b", 123]).should == "1111011"
+    it "calls methods prefixed with function_ as custom functions" do
+      scope.function_sprintf(["%b", 123]).should == "1111011"
     end
 
-    it "should raise and error when called without an Array" do
-      expect { @scope.function_sprintf("%b", 123) }.to raise_error ArgumentError, /custom functions must be called with a single array that contains the arguments/
+    it "raises an error when arguments are not passed in an Array" do
+      expect do
+        scope.function_sprintf("%b", 123)
+      end.to raise_error ArgumentError, /custom functions must be called with a single array that contains the arguments/
     end
 
-    it "should raise and error when subsequent calls are without an Array" do
-      @scope.function_sprintf(["first call"])
+    it "raises an error on subsequent calls when arguments are not passed in an Array" do
+      scope.function_sprintf(["first call"])
 
-      expect { @scope.function_sprintf("%b", 123) }.to raise_error ArgumentError, /custom functions must be called with a single array that contains the arguments/
+      expect do
+        scope.function_sprintf("%b", 123)
+      end.to raise_error ArgumentError, /custom functions must be called with a single array that contains the arguments/
     end
 
-    it "should raise NoMethodError if the method doesn't look like a function" do
-      expect { @scope.sprintf(["%b", 123]) }.to raise_error(NoMethodError)
+    it "raises NoMethodError when the not prefixed" do
+      expect { scope.sprintf(["%b", 123]) }.to raise_error(NoMethodError)
     end
 
-    it "should raise NoMethodError if the method looks like a function but doesn't exist" do
-      expect { @scope.function_fake_bs(['cows']) }.to raise_error(NoMethodError)
+    it "raises NoMethodError when prefixed with function_ but it doesn't exist" do
+      expect { scope.function_fake_bs(['cows']) }.to raise_error(NoMethodError)
     end
   end
 
@@ -493,6 +495,27 @@ describe Puppet::Parser::Scope do
     end
   end
 
+  context "when using ephemeral as local scope" do
+    it "should store all variables in local scope" do
+      @scope.new_ephemeral true
+      @scope.setvar("apple", :fruit)
+      @scope["apple"].should == :fruit
+    end
+
+    it "should remove all local scope variables on unset" do
+      @scope.new_ephemeral true
+      @scope.setvar("apple", :fruit)
+      @scope["apple"].should == :fruit
+      @scope.unset_ephemeral_var
+      @scope["apple"].should == nil
+    end
+    it "should be created from a hash" do
+      @scope.ephemeral_from({ "apple" => :fruit, "strawberry" => :berry})
+      @scope["apple"].should == :fruit
+      @scope["strawberry"].should == :berry
+    end
+  end
+
   describe "when setting ephemeral vars from matches" do
     before :each do
       @match = stub 'match', :is_a? => true