puppet 0.24.9 → 0.25.0

data/spec/unit/parser/ast.rb

@@ -5,7 +5,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/parser/ast'
 
 describe Puppet::Parser::AST do
-    
+
     it "should use the file lookup module" do
         Puppet::Parser::AST.ancestors.should be_include(Puppet::FileCollection::Lookup)
     end

data/spec/unit/parser/ast/arithmetic_operator.rb

@@ -4,7 +4,7 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Puppet::Parser::AST::ArithmeticOperator do
 
-	ast = Puppet::Parser::AST
+    ast = Puppet::Parser::AST
 
     before :each do
         @scope = Puppet::Parser::Scope.new()
@@ -17,7 +17,7 @@ describe Puppet::Parser::AST::ArithmeticOperator do
         lval.expects(:safeevaluate).with(@scope).returns(1)
         rval = stub "rval"
         rval.expects(:safeevaluate).with(@scope).returns(2)
-        
+
         operator = ast::ArithmeticOperator.new :rval => rval, :operator => "+", :lval => lval
         operator.evaluate(@scope)
     end
@@ -27,24 +27,24 @@ describe Puppet::Parser::AST::ArithmeticOperator do
     end
 
     it "should call Puppet::Parser::Scope.number?" do
-				Puppet::Parser::Scope.expects(:number?).with(1).returns(1)
-				Puppet::Parser::Scope.expects(:number?).with(2).returns(2)
-				
+        Puppet::Parser::Scope.expects(:number?).with(1).returns(1)
+        Puppet::Parser::Scope.expects(:number?).with(2).returns(2)
+
         ast::ArithmeticOperator.new(:lval => @one, :operator => "+", :rval => @two).evaluate(@scope)
     end
 
 
-		%w{ + - * / << >>}.each do |op|
-    	it "should call ruby Numeric '#{op}'" do
-					one = stub 'one'
-					two = stub 'two'
-        	operator = ast::ArithmeticOperator.new :lval => @one, :operator => op, :rval => @two
-					Puppet::Parser::Scope.stubs(:number?).with(1).returns(one)
-					Puppet::Parser::Scope.stubs(:number?).with(2).returns(two)
-					one.expects(:send).with(op,two)
-        	operator.evaluate(@scope)
-    	end
-		end
+    %w{ + - * / << >>}.each do |op|
+        it "should call ruby Numeric '#{op}'" do
+            one = stub 'one'
+            two = stub 'two'
+            operator = ast::ArithmeticOperator.new :lval => @one, :operator => op, :rval => @two
+            Puppet::Parser::Scope.stubs(:number?).with(1).returns(one)
+            Puppet::Parser::Scope.stubs(:number?).with(2).returns(two)
+            one.expects(:send).with(op,two)
+            operator.evaluate(@scope)
+        end
+    end
 
     it "should work even with numbers embedded in strings" do
         two = stub 'two', :safeevaluate => "2"
@@ -65,7 +65,7 @@ describe Puppet::Parser::AST::ArithmeticOperator do
         @scope.expects(:lookupvar).with("two").returns(2)
         one = ast::Variable.new( :value => "one" )
         two = ast::Variable.new( :value => "two" )
-        
+
         operator = ast::ArithmeticOperator.new :lval => one, :operator => "+", :rval => two
         operator.evaluate(@scope).should == 3
     end

data/spec/unit/parser/ast/astarray.rb

@@ -11,14 +11,14 @@ describe Puppet::Parser::AST::ASTArray do
         array = Puppet::Parser::AST::ASTArray.new :children => []
         array.should respond_to(:[])
     end
-    
+
     it "should evaluate all its children" do
         item1 = stub "item1", :is_a? => true
         item2 = stub "item2", :is_a? => true
 
         item1.expects(:safeevaluate).with(@scope).returns(123)
         item2.expects(:safeevaluate).with(@scope).returns(246)
-        
+
         operator = Puppet::Parser::AST::ASTArray.new :children => [item1,item2]
         operator.evaluate(@scope)
     end
@@ -29,9 +29,9 @@ describe Puppet::Parser::AST::ASTArray do
         item2.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
         item2.stubs(:instance_of?).with(Puppet::Parser::AST::ASTArray).returns(true)
         item2.stubs(:each).yields(item1)
-        
+
         item1.expects(:safeevaluate).with(@scope).returns(123)
-        
+
         operator = Puppet::Parser::AST::ASTArray.new :children => [item2]
         operator.evaluate(@scope).should == [123]
     end
@@ -42,9 +42,9 @@ describe Puppet::Parser::AST::ASTArray do
         item2.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
         item2.stubs(:instance_of?).with(Puppet::Parser::AST::ASTArray).returns(true)
         item2.stubs(:each).yields([item1])
-        
+
         item1.expects(:safeevaluate).with(@scope).returns(123)
-        
+
         operator = Puppet::Parser::AST::ASTArray.new :children => [item2]
         operator.evaluate(@scope).should == [123]
     end
@@ -55,12 +55,18 @@ describe Puppet::Parser::AST::ASTArray do
         item2.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
         item2.stubs(:instance_of?).with(Puppet::Parser::AST::ASTArray).returns(true)
         item2.stubs(:each).yields([item1])
-        
+
         item1.expects(:safeevaluate).with(@scope).returns([123])
-        
+
         operator = Puppet::Parser::AST::ASTArray.new :children => [item2]
         operator.evaluate(@scope).should == [[123]]
     end
-    
-    
+
+    it "should return a valid string with to_s" do
+        a = stub 'a', :is_a? => true, :to_s => "a"
+        b = stub 'b', :is_a? => true, :to_s => "b"
+        array = Puppet::Parser::AST::ASTArray.new :children => [a,b]
+
+        array.to_s.should == "[a, b]"
+    end
 end

data/spec/unit/parser/ast/boolean_operator.rb

@@ -16,8 +16,8 @@ describe Puppet::Parser::AST::BooleanOperator do
         lval = stub "lval"
         lval.expects(:safeevaluate).with(@scope).returns("true")
         rval = stub "rval", :safeevaluate => false
-				rval.expects(:safeevaluate).never
-        
+        rval.expects(:safeevaluate).never
+
         operator = ast::BooleanOperator.new :rval => rval, :operator => "or", :lval => lval
         operator.evaluate(@scope)
     end

data/spec/unit/parser/ast/casestatement.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::CaseStatement do
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    describe "when evaluating" do
+
+        before :each do
+            @test = stub 'test'
+            @test.stubs(:safeevaluate).with(@scope).returns("value")
+
+            @option1 = stub 'option1', :eachopt => nil, :default? => false
+            @option2 = stub 'option2', :eachopt => nil, :default? => false
+
+            @options = stub 'options'
+            @options.stubs(:each).multiple_yields(@option1, @option2)
+
+            @casestmt = Puppet::Parser::AST::CaseStatement.new :test => @test, :options => @options
+        end
+
+        it "should evaluate test" do
+            @test.expects(:safeevaluate).with(@scope)
+
+            @casestmt.evaluate(@scope)
+        end
+
+        it "should downcase the evaluated test value if allowed" do
+            Puppet.stubs(:[]).with(:casesensitive).returns(false)
+            value = stub 'test'
+            @test.stubs(:safeevaluate).with(@scope).returns(value)
+
+            value.expects(:downcase)
+
+            @casestmt.evaluate(@scope)
+        end
+
+        it "should scan each option" do
+            @options.expects(:each).multiple_yields(@option1, @option2)
+
+            @casestmt.evaluate(@scope)
+        end
+
+        describe "when scanning options" do
+            before :each do
+                @opval1 = stub_everything 'opval1'
+                @option1.stubs(:eachopt).yields(@opval1)
+
+                @opval2 = stub_everything 'opval2'
+                @option2.stubs(:eachopt).yields(@opval2)
+            end
+
+            it "should evaluate each sub-option" do
+                @option1.expects(:eachopt)
+                @option2.expects(:eachopt)
+
+                @casestmt.evaluate(@scope)
+            end
+
+            it "should evaluate first matching option" do
+                @opval2.stubs(:evaluate_match).with { |*arg| arg[0] == "value" }.returns(true)
+                @option2.expects(:safeevaluate).with(@scope)
+
+                @casestmt.evaluate(@scope)
+            end
+
+            it "should evaluate_match with sensitive parameter" do
+                Puppet.stubs(:[]).with(:casesensitive).returns(true)
+                @opval1.expects(:evaluate_match).with { |*arg| arg[2][:sensitive] == true }
+
+                @casestmt.evaluate(@scope)
+            end
+
+            it "should return the first matching evaluated option" do
+                @opval2.stubs(:evaluate_match).with { |*arg| arg[0] == "value" }.returns(true)
+                @option2.stubs(:safeevaluate).with(@scope).returns(:result)
+
+                @casestmt.evaluate(@scope).should == :result
+            end
+
+            it "should evaluate the default option if none matched" do
+                @option1.stubs(:default?).returns(true)
+                @option1.expects(:safeevaluate).with(@scope)
+
+                @casestmt.evaluate(@scope)
+            end
+
+            it "should return the default evaluated option if none matched" do
+                @option1.stubs(:default?).returns(true)
+                @option1.stubs(:safeevaluate).with(@scope).returns(:result)
+
+                @casestmt.evaluate(@scope).should == :result
+            end
+
+            it "should return nil if nothing matched" do
+                @casestmt.evaluate(@scope).should be_nil
+            end
+
+            it "should match and set scope ephemeral variables" do
+                @opval1.expects(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }
+
+                @casestmt.evaluate(@scope)
+            end
+
+            it "should evaluate this regex option if it matches" do
+                @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
+
+                @option1.expects(:safeevaluate).with(@scope)
+
+                @casestmt.evaluate(@scope)
+            end
+
+            it "should return this evaluated regex option if it matches" do
+                @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
+                @option1.stubs(:safeevaluate).with(@scope).returns(:result)
+
+                @casestmt.evaluate(@scope).should == :result
+            end
+
+            it "should unset scope ephemeral variables after option evaluation" do
+                @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
+                @option1.stubs(:safeevaluate).with(@scope).returns(:result)
+
+                @scope.expects(:unset_ephemeral_var)
+
+                @casestmt.evaluate(@scope)
+            end
+
+            it "should not leak ephemeral variables even if evaluation fails" do
+                @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
+                @option1.stubs(:safeevaluate).with(@scope).raises
+
+                @scope.expects(:unset_ephemeral_var)
+
+                lambda { @casestmt.evaluate(@scope) }.should raise_error
+            end
+        end
+
+    end
+end

data/spec/unit/parser/ast/collection.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Collection do
+    before :each do
+        @scope = stub_everything 'scope'
+        @compiler = stub_everything 'compile'
+        @scope.stubs(:compiler).returns(@compiler)
+
+        @overrides = stub_everything 'overrides'
+        @overrides.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
+
+    end
+
+    it "should evaluate its query" do
+        query = mock 'query'
+        collection = Puppet::Parser::AST::Collection.new :query => query, :form => :virtual
+
+        query.expects(:safeevaluate).with(@scope)
+
+        collection.evaluate(@scope)
+    end
+
+    it "should instantiate a Collector for this type" do
+        collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "test"
+
+        Puppet::Parser::Collector.expects(:new).with(@scope, "test", nil, nil, :virtual)
+
+        collection.evaluate(@scope)
+    end
+
+    it "should tell the compiler about this collector" do
+        collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "test"
+        Puppet::Parser::Collector.stubs(:new).returns("whatever")
+
+        @compiler.expects(:add_collection).with("whatever")
+
+        collection.evaluate(@scope)
+    end
+
+    it "should evaluate overriden paramaters" do
+        collector = stub_everything 'collector'
+        collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "test", :override => @overrides
+        Puppet::Parser::Collector.stubs(:new).returns(collector)
+
+        @overrides.expects(:safeevaluate).with(@scope)
+
+        collection.evaluate(@scope)
+    end
+
+    it "should tell the collector about overrides" do
+        collector = mock 'collector'
+        collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "test", :override => @overrides
+        Puppet::Parser::Collector.stubs(:new).returns(collector)
+
+        collector.expects(:add_override)
+
+        collection.evaluate(@scope)
+    end
+
+
+end

data/spec/unit/parser/ast/collexpr.rb

@@ -7,9 +7,9 @@ describe Puppet::Parser::AST::CollExpr do
     ast = Puppet::Parser::AST
 
     before :each do
-        @scope = Puppet::Parser::Scope.new()        
+        @scope = Puppet::Parser::Scope.new()
     end
-    
+
     describe "when evaluating with two operands" do
         before :each do
             @test1 = mock 'test1'
@@ -31,14 +31,14 @@ describe Puppet::Parser::AST::CollExpr do
         end
 
         it "should propagate expression type and form to child if expression themselves" do
-            [@test1, @test2].each do |t| 
+            [@test1, @test2].each do |t|
                 t.expects(:is_a?).returns(true)
                 t.expects(:form).returns(false)
                 t.expects(:type).returns(false)
                 t.expects(:type=)
                 t.expects(:form=)
             end
-        
+
             collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper=>"==", :form => true, :type => true)
             result = collexpr.evaluate(@scope)
         end
@@ -48,7 +48,7 @@ describe Puppet::Parser::AST::CollExpr do
                 @resource = mock 'resource'
                 @resource.expects(:[]).with("test1").at_least(1).returns("test2")
             end
-        
+
             it "should evaluate like the original expression for ==" do
                 collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper => "==")
                 collexpr.evaluate(@scope)[1].call(@resource).should === (@resource["test1"] == "test2")
@@ -73,17 +73,40 @@ describe Puppet::Parser::AST::CollExpr do
             end
         end
     end
-    
-    it "should check for array member equality if resource parameter is an array for ==" do
+
+    describe "when evaluating with tags" do
+        before :each do
+            @tag = stub 'tag', :safeevaluate => 'tag'
+            @value = stub 'value', :safeevaluate => 'value'
+
+            @resource = stub 'resource'
+            @resource.stubs(:tagged?).with("value").returns(true)
+        end
+
+        it "should produce a textual representation of the expression" do
+            collexpr = ast::CollExpr.new(:test1 => @tag, :test2 => @value, :oper=>"==")
+            result = collexpr.evaluate(@scope)
+            result[0].should == "puppet_tags.name = 'value'"
+        end
+
+        it "should inspect resource tags if the query term is on tags" do
+            collexpr = ast::CollExpr.new(:test1 => @tag, :test2 => @value, :oper => "==")
+            collexpr.evaluate(@scope)[1].call(@resource).should be_true
+        end
+    end
+
+    [:exported,:virtual].each do |mode|
+    it "should check for array member equality if resource parameter is an array for == in mode #{mode}" do
         array = mock 'array', :safeevaluate => "array"
         test1 = mock 'test1'
         test1.expects(:safeevaluate).with(@scope).returns("test1")
 
         resource = mock 'resource'
         resource.expects(:[]).with("array").at_least(1).returns(["test1","test2","test3"])
-        collexpr = ast::CollExpr.new(:test1 => array, :test2 => test1, :oper => "==")
+        collexpr = ast::CollExpr.new(:test1 => array, :test2 => test1, :oper => "==", :form => mode)
         collexpr.evaluate(@scope)[1].call(resource).should be_true
     end
+    end
 
     it "should raise an error for invalid operator" do
         lambda { collexpr = ast::CollExpr.new(:oper=>">") }.should raise_error

data/spec/unit/parser/ast/comparison_operator.rb

@@ -14,7 +14,7 @@ describe Puppet::Parser::AST::ComparisonOperator do
         lval.expects(:safeevaluate).with(@scope)
         rval = stub "rval"
         rval.expects(:safeevaluate).with(@scope)
-        
+
         operator = Puppet::Parser::AST::ComparisonOperator.new :lval => lval, :operator => "==", :rval => rval
         operator.evaluate(@scope)
     end
@@ -22,18 +22,18 @@ describe Puppet::Parser::AST::ComparisonOperator do
     it "should convert arguments strings to numbers if they are" do
         Puppet::Parser::Scope.expects(:number?).with("1").returns(1)
         Puppet::Parser::Scope.expects(:number?).with("2").returns(2)
-        
+
         operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => "==", :rval => @two
         operator.evaluate(@scope)
     end
-    
+
     %w{< > <= >= ==}.each do |oper|
         it "should use string comparison #{oper} if operands are strings" do
             lval = stub 'one', :safeevaluate => "one"
             rval = stub 'two', :safeevaluate => "two"
             Puppet::Parser::Scope.stubs(:number?).with("one").returns(nil)
             Puppet::Parser::Scope.stubs(:number?).with("two").returns(nil)
-    
+
             operator = Puppet::Parser::AST::ComparisonOperator.new :lval => lval, :operator => oper, :rval => rval
             operator.evaluate(@scope).should == "one".send(oper,"two")
         end
@@ -44,11 +44,11 @@ describe Puppet::Parser::AST::ComparisonOperator do
         rval = stub 'two', :safeevaluate => "2"
         Puppet::Parser::Scope.stubs(:number?).with("one").returns(nil)
         Puppet::Parser::Scope.stubs(:number?).with("2").returns(2)
-        
+
         operator = Puppet::Parser::AST::ComparisonOperator.new :lval => lval, :operator => ">", :rval => rval
         lambda { operator.evaluate(@scope) }.should raise_error(ArgumentError)
     end
-    
+
     it "should fail for an unknown operator" do
         lambda { operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => "or", :rval => @two }.should raise_error
     end
@@ -56,7 +56,7 @@ describe Puppet::Parser::AST::ComparisonOperator do
     %w{< > <= >= ==}.each do |oper|
        it "should return the result of using '#{oper}' to compare the left and right sides" do
            operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => oper, :rval => @two
-           
+
            operator.evaluate(@scope).should == 1.send(oper,2)
        end
     end
@@ -73,7 +73,7 @@ describe Puppet::Parser::AST::ComparisonOperator do
 
         @scope.expects(:lookupvar).with("one").returns(1)
         @scope.expects(:lookupvar).with("two").returns(2)
-        
+
         operator = Puppet::Parser::AST::ComparisonOperator.new :lval => one, :operator => "<", :rval => two
         operator.evaluate(@scope).should == true
     end
@@ -84,7 +84,7 @@ describe Puppet::Parser::AST::ComparisonOperator do
            ten = stub 'one', :safeevaluate => "10"
            nine = stub 'two', :safeevaluate => "9"
            operator = Puppet::Parser::AST::ComparisonOperator.new :lval => ten, :operator => oper, :rval => nine
-           
+
            operator.evaluate(@scope).should == 10.send(oper,9)
        end
     end