puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/parser/functions_spec.rb

@@ -6,24 +6,19 @@ describe Puppet::Parser::Functions do
     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)
-  end
+  let(:function_module) { Puppet::Parser::Functions.environment_module(Puppet.lookup(:current_environment)) }
+
+  let(:environment) { Puppet::Node::Environment.create(:myenv, [], '') }
 
-  it "should use the current default environment if no environment is provided" do
-    Puppet::Parser::Functions.environment_module.should be_instance_of(Module)
+  before do
+    Puppet::Parser::Functions.reset
   end
 
-  it "should be able to retrieve environment modules asked for by name rather than instance" do
-    Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.new("myenv")).should equal(Puppet::Parser::Functions.environment_module("myenv"))
+  it "should have a method for returning an environment-specific module" do
+    Puppet::Parser::Functions.environment_module(environment).should be_instance_of(Module)
   end
 
   describe "when calling newfunction" do
-    let(:function_module) { Module.new }
-    before do
-      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| }
 
@@ -41,7 +36,7 @@ describe Puppet::Parser::Functions do
       expect { Puppet::Parser::Functions.newfunction("name", :type => :unknown) { |args| } }.to raise_error Puppet::DevError, "Invalid statement type :unknown"
     end
 
-    it "instruments the function to profiles the execution" do
+    it "instruments the function to profile the execution" do
       messages = []
       Puppet::Util::Profiler.current = Puppet::Util::Profiler::WallClock.new(proc { |msg| messages << msg }, "id")
 
@@ -53,11 +48,6 @@ describe Puppet::Parser::Functions do
   end
 
   describe "when calling function to test function existence" do
-    let(:function_module) { Module.new }
-    before do
-      Puppet::Parser::Functions.stubs(:environment_module).returns(function_module)
-    end
-
     it "should return false if the function doesn't exist" do
       Puppet::Parser::Functions.autoloader.stubs(:load)
 
@@ -75,6 +65,23 @@ describe Puppet::Parser::Functions do
 
       Puppet::Parser::Functions.function("name")
     end
+
+    it "combines functions from the root with those from the current environment" do
+      Puppet.override(:current_environment => Puppet.lookup(:root_environment)) do
+        Puppet::Parser::Functions.newfunction("onlyroot", :type => :rvalue) do |args|
+        end
+      end
+
+      Puppet.override(:current_environment => Puppet::Node::Environment.create(:other, [], '')) do
+        Puppet::Parser::Functions.newfunction("other_env", :type => :rvalue) do |args|
+        end
+
+        expect(Puppet::Parser::Functions.function("onlyroot")).to eq("function_onlyroot")
+        expect(Puppet::Parser::Functions.function("other_env")).to eq("function_other_env")
+      end
+
+      expect(Puppet::Parser::Functions.function("other_env")).to be_false
+    end
   end
 
   describe "when calling function to test arity" do
@@ -125,77 +132,4 @@ describe Puppet::Parser::Functions do
       Puppet::Parser::Functions.arity(:name).should == -1
     end
   end
-
-  describe "::get_function" do
-    it "can retrieve a function defined on the *root* environment" do
-      $environment = nil
-      function = Puppet::Parser::Functions.newfunction("atest", :type => :rvalue) do
-        nil
-      end
-
-      Puppet::Node::Environment.current = "test_env"
-      Puppet::Parser::Functions.send(:get_function, "atest").should equal(function)
-    end
-
-    it "can retrieve a function from the current environment" do
-      Puppet::Node::Environment.current = "test_env"
-      function = Puppet::Parser::Functions.newfunction("atest", :type => :rvalue) do
-        nil
-      end
-
-      Puppet::Parser::Functions.send(:get_function, "atest").should equal(function)
-    end
-
-    it "takes a function in the current environment over one in the root" do
-      root = Puppet::Node::Environment.root
-      env = Puppet::Node::Environment.current = "test_env"
-      func1 = {:type => :rvalue, :name => :testfunc, :extra => :func1}
-      func2 = {:type => :rvalue, :name => :testfunc, :extra => :func2}
-      Puppet::Parser::Functions.instance_eval do
-        @functions[Puppet::Node::Environment.root][:atest] = func1
-        @functions[Puppet::Node::Environment.current][:atest] = func2
-      end
-
-      Puppet::Parser::Functions.send(:get_function, "atest").should equal(func2)
-    end
-  end
-
-  describe "::merged_functions" do
-    it "returns functions in both the current and root environment" do
-      $environment = nil
-      func_a = Puppet::Parser::Functions.newfunction("test_a", :type => :rvalue) do
-        nil
-      end
-      Puppet::Node::Environment.current = "test_env"
-      func_b = Puppet::Parser::Functions.newfunction("test_b", :type => :rvalue) do
-        nil
-      end
-
-      Puppet::Parser::Functions.send(:merged_functions).should include(:test_a, :test_b)
-    end
-
-    it "returns functions from the current environment over the root environment" do
-      root = Puppet::Node::Environment.root
-      env = Puppet::Node::Environment.current = "test_env"
-      func1 = {:type => :rvalue, :name => :testfunc, :extra => :func1}
-      func2 = {:type => :rvalue, :name => :testfunc, :extra => :func2}
-      Puppet::Parser::Functions.instance_eval do
-        @functions[Puppet::Node::Environment.root][:atest] = func1
-        @functions[Puppet::Node::Environment.current][:atest] = func2
-      end
-
-      Puppet::Parser::Functions.send(:merged_functions)[:atest].should equal(func2)
-    end
-  end
-
-  describe "::add_function" do
-    it "adds functions to the current environment" do
-      func = {:type => :rvalue, :name => :testfunc}
-      Puppet::Node::Environment.current = "add_function_test"
-      Puppet::Parser::Functions.send(:add_function, :testfunc, func)
-
-      Puppet::Parser::Functions.instance_variable_get(:@functions)[Puppet::Node::Environment.root].should_not include(:testfunc)
-      Puppet::Parser::Functions.instance_variable_get(:@functions)[Puppet::Node::Environment.current].should include(:testfunc)
-    end
-  end
 end

data/spec/unit/parser/lexer_spec.rb

@@ -861,7 +861,7 @@ describe "when trying to lex a non-existent file" do
   it "should return an empty list of tokens" do
     lexer = Puppet::Parser::Lexer.new
     lexer.file = nofile = tmpfile('lexer')
-    Puppet::FileSystem::File.exist?(nofile).should == false
+    Puppet::FileSystem.exist?(nofile).should == false
 
     lexer.fullscan.should == [[false,false]]
   end

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

@@ -23,6 +23,32 @@ describe 'the filter method' do
     catalog.resource(:file, "/file_blueberry")['ensure'].should == 'present'
   end
 
+  it 'should filter on enumerable type (Integer)' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = Integer[1,10]
+      $a.filter |$x|{ $x  % 3 == 0}.each |$v|{
+        file { "/file_$v": ensure => present }
+      }
+    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'
+  end
+
+  it 'should filter on enumerable type (Integer) using two args index/value' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = Integer[10,18]
+      $a.filter |$i, $x|{ $i  % 3 == 0}.each |$v|{
+        file { "/file_$v": ensure => present }
+      }
+    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'
+  end
+
   it 'should produce an array when acting on an array' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = ['strawberry','blueberry','orange']
@@ -35,6 +61,18 @@ describe 'the filter method' do
     catalog.resource(:file, "/file_blueberry")['ensure'].should == 'present'
   end
 
+  it 'can filter array using index and value' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      $a = ['strawberry','blueberry','orange']
+      $b = $a.filter |$index, $x|{ $index  == 0 or $index ==2}
+      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_orange")['ensure'].should == 'present'
+  end
+
   it 'filters on a hash (all berries) by key' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'strawberry'=>'red','blueberry'=>'blue','orange'=>'orange'}
@@ -74,6 +112,24 @@ describe 'the filter method' do
     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
+  end
+
   it_should_behave_like 'all iterative functions argument checks', 'filter'
   it_should_behave_like 'all iterative functions hash handling', 'filter'
 end

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

@@ -25,6 +25,56 @@ describe 'the map method' do
       catalog.resource(:file, "/file_6")['ensure'].should == '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
+
+      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 '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
+
+      catalog.resource(:file, "/file_0")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_6")['ensure'].should == '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
+
+      catalog.resource(:file, "/file_x")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_y")['ensure'].should == '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
+
+      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_20")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+    end
+
     it 'map on a hash selecting keys' do
       catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'a'=>1,'b'=>2,'c'=>3}
@@ -38,14 +88,35 @@ describe 'the map method' do
       catalog.resource(:file, "/file_c")['ensure'].should == 'present'
     end
 
-    it 'each on a hash selecting value' do
+    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 |$x|{ $x[1]}.each |$k|{
-          file { "/file_$k": ensure => present }
+      $a.map |$k,$v|{ 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 '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
+
+      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 a hash selecting value - using two bloc parameters' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'a'=>1,'b'=>2,'c'=>3}
+      $a.map |$k,$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'
@@ -85,10 +156,28 @@ describe 'the map method' do
             file { "/file_$i.$v": ensure => present }
           }
         MANIFEST
-
-        catalog.resource(:file, "/file_0.")['ensure'].should == 'present'
+        catalog.resource(:file, "/file_0.something")['ensure'].should == 'present'
       end
     end
+
+  context 'map checks arguments and' do
+    it 'raises an error when block has more than 2 argument' do
+      expect do
+        compile_to_catalog(<<-MANIFEST)
+          [1].map |$index, $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].map || {  }
+        MANIFEST
+      end.to raise_error(Puppet::Error, /block must define at least one parameter/)
+    end
+  end
+
   it_should_behave_like 'all iterative functions argument checks', 'map'
   it_should_behave_like 'all iterative functions hash handling', 'map'
   end

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

@@ -35,6 +35,16 @@ describe 'the reduce method' do
       catalog.resource(:file, "/file_6")['ensure'].should == 'present'
     end
 
+    it 'reduce on enumerable type' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = Integer[1,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]

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

@@ -11,28 +11,12 @@ 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| {  }
+        3.14.#{func} |$v| {  }
       MANIFEST
-    end.to raise_error(Puppet::Error, /must be an Array or a Hash/)
+    end.to raise_error(Puppet::Error, /must be something enumerable/)
   end
 
   it 'raises an error when called with any parameters besides a block' do

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

@@ -40,6 +40,7 @@ describe 'methods' do
       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]
@@ -52,6 +53,7 @@ describe 'methods' do
       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]
@@ -64,8 +66,8 @@ describe 'methods' do
       catalog.resource(:file, "/file_3.")['ensure'].should == 'absent'
     end
   end
-  context "should be callable on hash as" do
 
+  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}
@@ -77,8 +79,44 @@ describe 'methods' do
       catalog.resource(:file, "/file_1.2")['ensure'].should == 'present'
       catalog.resource(:file, "/file_3.")['ensure'].should == 'absent'
     end
+  end
+
+  context "should be callable on enumerable types as" do
+    it 'slice with integer range' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = Integer[1,4]
+        $a.slice(2) |$a,$b| {
+          file { "/file_${a}.${b}": ensure => present }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_1.2")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_3.4")['ensure'].should == 'present'
+    end
 
+    it 'slice with integer' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        4.slice(2) |$a,$b| {
+          file { "/file_${a}.${b}": ensure => present }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_0.1")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_2.3")['ensure'].should == 'present'
+    end
+
+    it 'slice with string' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        'abcd'.slice(2) |$a,$b| {
+          file { "/file_${a}.${b}": ensure => present }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_a.b")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_c.d")['ensure'].should == 'present'
+    end
   end
+
   context "when called without a block" do
     it "should produce an array with the result" do
       catalog = compile_to_catalog(<<-MANIFEST)