puppet 3.1.1 → 3.2.0.rc1

data/spec/unit/parser/functions/extlookup_spec.rb

@@ -1,6 +1,5 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-require 'tempfile'
 
 describe "the extlookup function" do
   include PuppetSpec::Files
@@ -33,36 +32,40 @@ describe "the extlookup function" do
   end
 
   it "should lookup the key in a supplied datafile" do
-    t = Tempfile.new('extlookup.csv') do
+    dir = tmpdir("extlookup_spec")
+    File.open("#{dir}/extlookup.csv", "w") do |t|
       t.puts 'key,value'
       t.puts 'nonkey,nonvalue'
-      t.close
-
-      result = @scope.function_extlookup([ "key", "default", t.path])
-      result.should == "value"
     end
+
+    @scope.stubs(:[]).with('::extlookup_datadir').returns(dir)
+    @scope.stubs(:[]).with('::extlookup_precedence').returns(nil)
+    result = @scope.function_extlookup([ "key", "default", "extlookup"])
+    result.should == "value"
   end
 
   it "should return an array if the datafile contains more than two columns" do
-    t = Tempfile.new('extlookup.csv') do
+    dir = tmpdir("extlookup_spec")
+    File.open("#{dir}/extlookup.csv", "w") do |t|
       t.puts 'key,value1,value2'
       t.puts 'nonkey,nonvalue,nonvalue'
-      t.close
-
-      result = @scope.function_extlookup([ "key", "default", t.path])
-      result.should == ["value1", "value2"]
     end
+
+    @scope.stubs(:[]).with('::extlookup_datadir').returns(dir)
+    @scope.stubs(:[]).with('::extlookup_precedence').returns(nil)
+    result = @scope.function_extlookup([ "key", "default", "extlookup"])
+    result.should == ["value1", "value2"]
   end
 
   it "should raise an error if there's no matching key and no default" do
-    t = Tempfile.new('extlookup.csv') do
-      t.puts 'key,value'
+    dir = tmpdir("extlookup_spec")
+    File.open("#{dir}/extlookup.csv", "w") do |t|
       t.puts 'nonkey,nonvalue'
-      t.close
-
-      result = @scope.function_extlookup([ "key", nil, t.path])
-      result.should == "value"
     end
+
+    @scope.stubs(:[]).with('::extlookup_datadir').returns(dir)
+    @scope.stubs(:[]).with('::extlookup_precedence').returns(nil)
+    lambda { @scope.function_extlookup([ "key", nil, "extlookup"]) }.should raise_error(Puppet::ParseError, /No match found.*key/)
   end
 
   describe "should look in $extlookup_datadir for data files listed by $extlookup_precedence" do

data/spec/unit/parser/functions/fqdn_rand_spec.rb

@@ -55,4 +55,9 @@ describe "the fqdn_rand function" do
     val2 = @scope.function_fqdn_rand([10000000,42])
     val1.should_not eql(val2)
   end
+
+  it "should use the Puppet::Util function" do
+    Puppet::Util.expects(:deterministic_rand).with(177093203648075535190027737376590689559,4)
+    @scope.function_fqdn_rand([4])
+  end
 end

data/spec/unit/parser/functions/hiera_include_spec.rb

@@ -1,6 +1,4 @@
 require 'spec_helper'
-require 'hiera_puppet'
-require 'puppet/parser/functions/hiera_include'
 
 describe 'Puppet::Parser::Functions#hiera_include' do
   let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end

data/spec/unit/parser/functions/hiera_spec.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 
 describe 'Puppet::Parser::Functions#hiera' do

data/spec/unit/parser/functions_spec.rb

@@ -2,6 +2,9 @@
 require 'spec_helper'
 
 describe Puppet::Parser::Functions do
+  def callable_functions_from(mod)
+    Class.new { include mod }.new
+  end
 
   it "should have a method for returning an environment-specific module" do
     Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.new("myenv")).should be_instance_of(Module)
@@ -16,15 +19,15 @@ describe Puppet::Parser::Functions do
   end
 
   describe "when calling newfunction" do
+    let(:function_module) { Module.new }
     before do
-      @module = Module.new
-      Puppet::Parser::Functions.stubs(:environment_module).returns @module
+      Puppet::Parser::Functions.stubs(:environment_module).returns(function_module)
     end
 
     it "should create the function in the environment module" do
       Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
 
-      @module.should be_method_defined :function_name
+      function_module.should be_method_defined :function_name
     end
 
     it "should warn if the function already exists" do
@@ -37,12 +40,22 @@ describe Puppet::Parser::Functions do
     it "should raise an error if the function type is not correct" do
       lambda { Puppet::Parser::Functions.newfunction("name", :type => :unknown) { |args| } }.should raise_error Puppet::DevError, "Invalid statement type :unknown"
     end
+
+    it "instruments the function to profiles the execution" do
+      messages = []
+      Puppet::Util::Profiler.current = Puppet::Util::Profiler::WallClock.new(proc { |msg| messages << msg }, "id")
+
+      Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
+      callable_functions_from(function_module).function_name([])
+
+      messages.first.should =~ /Called name/
+    end
   end
 
   describe "when calling function to test function existence" do
+    let(:function_module) { Module.new }
     before do
-      @module = Module.new
-      Puppet::Parser::Functions.stubs(:environment_module).returns @module
+      Puppet::Parser::Functions.stubs(:environment_module).returns(function_module)
     end
 
     it "should return false if the function doesn't exist" do
@@ -65,40 +78,39 @@ describe Puppet::Parser::Functions do
   end
 
   describe "when calling function to test arity" do
-    before :each do
-      Puppet::Node::Environment.stubs(:current).returns(nil)
-      @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
-      @scope = Puppet::Parser::Scope.new(@compiler)
+    let(:function_module) { Module.new }
+    before do
+      Puppet::Parser::Functions.stubs(:environment_module).returns(function_module)
     end
 
     it "should raise an error if the function is called with too many arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => 2) { |args| }
-      lambda { @scope.function_name([1,2,3]) }.should raise_error ArgumentError
+      lambda { callable_functions_from(function_module).function_name([1,2,3]) }.should raise_error ArgumentError
     end
 
     it "should raise an error if the function is called with too few arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => 2) { |args| }
-      lambda { @scope.function_name([1]) }.should raise_error ArgumentError
+      lambda { callable_functions_from(function_module).function_name([1]) }.should raise_error ArgumentError
     end
 
     it "should not raise an error if the function is called with correct number of arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => 2) { |args| }
-      lambda { @scope.function_name([1,2]) }.should_not raise_error ArgumentError
+      lambda { callable_functions_from(function_module).function_name([1,2]) }.should_not raise_error ArgumentError
     end
 
     it "should raise an error if the variable arg function is called with too few arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => -3) { |args| }
-      lambda { @scope.function_name([1]) }.should raise_error ArgumentError
+      lambda { callable_functions_from(function_module).function_name([1]) }.should raise_error ArgumentError
     end
 
     it "should not raise an error if the variable arg function is called with correct number of arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => -3) { |args| }
-      lambda { @scope.function_name([1,2]) }.should_not raise_error ArgumentError
+      lambda { callable_functions_from(function_module).function_name([1,2]) }.should_not raise_error ArgumentError
     end
 
     it "should not raise an error if the variable arg function is called with more number of arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => -3) { |args| }
-      lambda { @scope.function_name([1,2,3]) }.should_not raise_error ArgumentError
+      lambda { callable_functions_from(function_module).function_name([1,2,3]) }.should_not raise_error ArgumentError
     end
   end
 

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

@@ -0,0 +1,110 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+require 'unit/parser/methods/shared'
+
+describe 'the collect method' do
+  include PuppetSpec::Compiler
+
+  before :each do
+    Puppet[:parser] = "future"
+  end
+
+  context "using future parser" do
+    context "in Ruby style should be callable as" do
+      it 'collect on an array (multiplying each value by 2)' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          $a = [1,2,3]
+          $a.collect {|$x| $x*2}.foreach {|$v| 
+            file { "/file_$v": ensure => present }
+          }
+        MANIFEST
+
+        catalog.resource(:file, "/file_2")['ensure'].should == 'present'
+        catalog.resource(:file, "/file_4")['ensure'].should == 'present'
+        catalog.resource(:file, "/file_6")['ensure'].should == 'present'
+      end
+
+      it 'collect on a hash selecting keys' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>1,'b'=>2,'c'=>3}
+        $a.collect {|$x| $x[0]}.foreach {|$k| 
+            file { "/file_$k": ensure => present }
+          }
+        MANIFEST
+
+        catalog.resource(:file, "/file_a")['ensure'].should == 'present'
+        catalog.resource(:file, "/file_b")['ensure'].should == 'present'
+        catalog.resource(:file, "/file_c")['ensure'].should == 'present'
+      end
+      it 'foreach on a hash selecting value' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>1,'b'=>2,'c'=>3}
+        $a.collect {|$x| $x[1]}.foreach {|$k| 
+            file { "/file_$k": ensure => present }
+          }
+        MANIFEST
+
+        catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+        catalog.resource(:file, "/file_2")['ensure'].should == 'present'
+        catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+      end
+    end
+    context "in Java style should be callable as" do
+      shared_examples_for 'java style' do
+        it 'collect on an array (multiplying each value by 2)' do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            $a = [1,2,3]
+            $a.collect |$x| #{farr}{ $x*2}.foreach |$v| #{farr}{ 
+              file { "/file_$v": ensure => present }
+            }
+          MANIFEST
+
+          catalog.resource(:file, "/file_2")['ensure'].should == 'present'
+          catalog.resource(:file, "/file_4")['ensure'].should == 'present'
+          catalog.resource(:file, "/file_6")['ensure'].should == 'present'
+        end
+
+        it 'collect on a hash selecting keys' do
+          catalog = compile_to_catalog(<<-MANIFEST)
+          $a = {'a'=>1,'b'=>2,'c'=>3}
+          $a.collect |$x| #{farr}{ $x[0]}.foreach |$k| #{farr}{ 
+              file { "/file_$k": ensure => present }
+            }
+          MANIFEST
+
+          catalog.resource(:file, "/file_a")['ensure'].should == 'present'
+          catalog.resource(:file, "/file_b")['ensure'].should == 'present'
+          catalog.resource(:file, "/file_c")['ensure'].should == 'present'
+        end
+
+        it 'foreach on a hash selecting value' do
+          catalog = compile_to_catalog(<<-MANIFEST)
+          $a = {'a'=>1,'b'=>2,'c'=>3}
+          $a.collect |$x| #{farr} {$x[1]}.foreach |$k|#{farr}{ 
+              file { "/file_$k": ensure => present }
+            }
+          MANIFEST
+
+          catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+          catalog.resource(:file, "/file_2")['ensure'].should == 'present'
+          catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+        end
+      end
+      describe 'without fat arrow' do
+        it_should_behave_like 'java style' do
+          let(:farr) { '' }
+        end
+      end
+      describe 'with fat arrow' do
+        it_should_behave_like 'java style' do
+          let(:farr) { '=>' }
+        end
+      end
+    end
+  end
+
+  it_should_behave_like 'all iterative functions argument checks', 'collect'
+  it_should_behave_like 'all iterative functions hash handling', 'collect'
+end

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

@@ -0,0 +1,91 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'rubygems'
+
+describe 'the each method' do
+  include PuppetSpec::Compiler
+
+  before :each do
+    Puppet[:parser] = 'future'
+  end
+
+  context "should be callable as" do
+    it 'each on an array selecting each value' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $a.each |$v| {
+          file { "/file_$v": ensure => present }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+      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]
+        each ($a) |$index, $v| => {
+          file { "/file_$v": ensure => present }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_2")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+    end
+
+    it 'each on an array with index' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [present, absent, present]
+        $a.each |$k,$v| {
+          file { "/file_${$k+1}": 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 'each on a hash selecting entries' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>'present','b'=>'absent','c'=>'present'}
+        $a.each |$e| {
+        file { "/file_${e[0]}": ensure => $e[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
+    it 'each on a hash selecting key and value' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>present,'b'=>absent,'c'=>present}
+        $a.each |$k, $v| {
+          file { "/file_$k": ensure => $v }
+        }
+      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)
+        $a = [1, 3, 2]
+        $b = $a.each |$x| { "unwanted" }
+        file { "/file_${b[1]}":
+          ensure => present
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+    end
+
+  end
+end

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

@@ -0,0 +1,91 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'rubygems'
+
+describe 'the foreach method' do
+  include PuppetSpec::Compiler
+
+  before :each do
+    Puppet[:parser] = 'future'
+  end
+
+  context "should be callable as" do
+    it 'foreach on an array selecting each value' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $a.foreach {|$v| 
+          file { "/file_$v": ensure => present }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_2")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+    end
+    it 'foreach on an array selecting each value - function call style' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        foreach ($a) {|$v| 
+          file { "/file_$v": ensure => present }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_2")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+    end
+
+    it 'foreach on an array with index' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [present, absent, present]
+        $a.foreach {|$k,$v| 
+          file { "/file_${$k+1}": 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 'foreach on a hash selecting entries' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>'present','b'=>'absent','c'=>'present'}
+        $a.foreach {|$e| 
+        file { "/file_${e[0]}": ensure => $e[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
+    it 'foreach on a hash selecting key and value' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>present,'b'=>absent,'c'=>present}
+        $a.foreach {|$k, $v| 
+          file { "/file_$k": ensure => $v }
+        }
+      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)
+        $a = [1, 3, 2]
+        $b = $a.each |$x| { $x }
+        file { "/file_${b[1]}":
+          ensure => present
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+    end
+
+  end
+end