puppet 0.24.6 → 0.24.7

data/spec/unit/other/transobject.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/transportable'
+
+describe Puppet::TransObject do
+    it "should canonize resource references" do
+        resource = Puppet::TransObject.new("me", "foo::bar")
+        resource.ref.should == 'Foo::Bar[me]'
+    end
+
+    it "should lower-case resource types for backward compatibility with 0.23.2" do
+        resource = Puppet::TransObject.new("me", "Foo")
+        resource.type.should == 'foo'
+    end
+end
+
+describe Puppet::TransObject, " when serializing" do
+    before do
+        @resource = Puppet::TransObject.new("/my/file", "file")
+        @resource["one"] = "test"
+        @resource["two"] = "other"
+    end
+
+    it "should be able to be dumped to yaml" do
+        proc { YAML.dump(@resource) }.should_not raise_error
+    end
+
+    it "should produce an equivalent yaml object" do
+        text = YAML.dump(@resource)
+
+        newresource = YAML.load(text)
+        newresource.name.should == "/my/file"
+        newresource.type.should == "file"
+        %w{one two}.each do |param|
+            newresource[param].should == @resource[param]
+        end
+    end
+end
+
+describe Puppet::TransObject, " when converting to a RAL resource" do
+    before do
+        @resource = Puppet::TransObject.new("/my/file", "file")
+        @resource["one"] = "test"
+        @resource["two"] = "other"
+    end
+
+    it "should use the resource type's :create method to create the resource" do
+        type = mock 'resource type'
+        type.expects(:create).with(@resource).returns(:myresource)
+        Puppet::Type.expects(:type).with("file").returns(type)
+        @resource.to_type.should == :myresource
+    end
+
+    it "should convert to a component instance if the resource type cannot be found" do
+        Puppet::Type.expects(:type).with("file").returns(nil)
+        @resource.expects(:to_component).returns(:mycomponent)
+        @resource.to_type.should == :mycomponent
+    end
+end
+
+describe Puppet::TransObject, " when converting to a RAL component instance" do
+    before do
+        @resource = Puppet::TransObject.new("/my/file", "one::two")
+        @resource["one"] = "test"
+        @resource["noop"] = "other"
+    end
+
+    it "should use a new TransObject whose name is a resource reference of the type and title of the original TransObject" do
+        Puppet::Type::Component.expects(:create).with { |resource| resource.type == "component" and resource.name == "One::Two[/my/file]" }.returns(:yay)
+        @resource.to_component.should == :yay
+    end
+
+    it "should pass the resource parameters on to the newly created TransObject" do
+        Puppet::Type::Component.expects(:create).with { |resource| resource["noop"] == "other" }.returns(:yay)
+        @resource.to_component.should == :yay
+    end
+
+    it "should copy over the catalog" do
+        @resource.catalog = "mycat"
+        Puppet::Type::Component.expects(:create).with { |resource| resource.catalog == "mycat" }.returns(:yay)
+        @resource.to_component
+    end
+
+    # LAK:FIXME This really isn't the design we want going forward, but it's
+    # good enough for now.
+    it "should not pass resource parameters that are not metaparams" do
+        Puppet::Type::Component.expects(:create).with { |resource| resource["one"].nil? }.returns(:yay)
+        @resource.to_component.should == :yay
+    end
+end

data/spec/unit/parameter.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'puppet/parameter'
+
+describe Puppet::Parameter do
+    describe "when returning the value" do
+        before do
+            @class = Class.new(Puppet::Parameter)
+            @class.initvars
+            @parameter = @class.new :resource => mock('resource')
+        end
+
+        it "should return nil if no value is set" do
+            @parameter.value.should be_nil
+        end
+
+        it "should return any set value" do
+            @parameter.value = "foo"
+            @parameter.value.should == "foo"
+        end
+    end
+end

data/spec/unit/parser/ast.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/parser/ast'
+
+describe Puppet::Parser::AST do
+
+    it "should have a doc accessor" do
+        ast = Puppet::Parser::AST.new({})
+        ast.should respond_to(:doc)
+    end
+
+    it "should have a use_docs accessor to indicate it wants documentation" do
+        ast = Puppet::Parser::AST.new({})
+        ast.should respond_to(:use_docs)
+    end
+
+    [ Puppet::Parser::AST::Collection, Puppet::Parser::AST::Definition, Puppet::Parser::AST::Else,
+      Puppet::Parser::AST::Function, Puppet::Parser::AST::HostClass, Puppet::Parser::AST::IfStatement,
+      Puppet::Parser::AST::Node, Puppet::Parser::AST::Resource, Puppet::Parser::AST::ResourceDefaults,
+      Puppet::Parser::AST::ResourceOverride, Puppet::Parser::AST::VarDef
+    ].each do |k|
+        it "#{k}.use_docs should return true" do
+            ast = k.new({})
+            ast.use_docs.should be_true
+        end
+    end
+
+    describe "when initializing" do
+        it "should store the doc argument if passed" do
+            ast = Puppet::Parser::AST.new(:doc => "documentation")
+            ast.doc.should == "documentation"
+        end
+    end
+
+end

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

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::ArithmeticOperator do
+
+	ast = Puppet::Parser::AST
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+        @one = stub 'lval', :safeevaluate => 1
+        @two = stub 'rval', :safeevaluate => 2
+    end
+
+    it "should evaluate both branches" do
+        lval = stub "lval"
+        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
+
+    it "should fail for an unknown operator" do
+        lambda { operator = ast::ArithmeticOperator.new :lval => @one, :operator => "%", :rval => @two }.should raise_error
+    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)
+				
+        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
+
+    it "should work even with numbers embedded in strings" do
+        two = stub 'two', :safeevaluate => "2"
+        one = stub 'one', :safeevaluate => "1"
+        operator = ast::ArithmeticOperator.new :lval => two, :operator => "+", :rval => one
+        operator.evaluate(@scope).should == 3
+    end
+
+    it "should work even with floats" do
+        two = stub 'two', :safeevaluate => 2.53
+        one = stub 'one', :safeevaluate => 1.80
+        operator = ast::ArithmeticOperator.new :lval => two, :operator => "+", :rval => one
+        operator.evaluate(@scope).should == 4.33
+    end
+
+    it "should work for variables too" do
+        @scope.expects(:lookupvar).with("one").returns(1)
+        @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
+
+end

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

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::ASTArray do
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should have a [] accessor" 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
+
+    it "should evaluate childrens of type ASTArray" do
+        item1 = stub "item1", :is_a? => true
+        item2 = stub "item2"
+        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 flatten children coming from children ASTArray" do
+        item1 = stub "item1", :is_a? => true
+        item2 = stub "item2"
+        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 flatten the results of children evaluation" do
+        item1 = stub "item1", :is_a? => true
+        item2 = stub "item2"
+        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
+    
+    
+end

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

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::BooleanOperator do
+
+    ast = Puppet::Parser::AST
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+        @true_ast = ast::Boolean.new( :value => true)
+        @false_ast = ast::Boolean.new( :value => false)
+    end
+
+    it "should evaluate left operand inconditionally" do
+        lval = stub "lval"
+        lval.expects(:safeevaluate).with(@scope).returns("true")
+        rval = stub "rval", :safeevaluate => false
+				rval.expects(:safeevaluate).never
+        
+        operator = ast::BooleanOperator.new :rval => rval, :operator => "or", :lval => lval
+        operator.evaluate(@scope)
+    end
+
+    it "should evaluate right 'and' operand only if left operand is true" do
+        lval = stub "lval", :safeevaluate => true
+        rval = stub "rval", :safeevaluate => false
+        rval.expects(:safeevaluate).with(@scope).returns(false)
+        operator = ast::BooleanOperator.new :rval => rval, :operator => "and", :lval => lval
+        operator.evaluate(@scope)
+    end
+
+    it "should evaluate right 'or' operand only if left operand is false" do
+        lval = stub "lval", :safeevaluate => false
+        rval = stub "rval", :safeevaluate => false
+        rval.expects(:safeevaluate).with(@scope).returns(false)
+        operator = ast::BooleanOperator.new :rval => rval, :operator => "or", :lval => lval
+        operator.evaluate(@scope)
+    end
+
+    it "should return true for false OR true" do
+        ast::BooleanOperator.new(:rval => @true_ast, :operator => "or", :lval => @false_ast).evaluate(@scope).should be_true
+    end
+
+    it "should return false for true AND false" do
+        ast::BooleanOperator.new(:rval => @true_ast, :operator => "and", :lval => @false_ast ).evaluate(@scope).should be_false
+    end
+
+    it "should return true for true AND true" do
+        ast::BooleanOperator.new(:rval => @true_ast, :operator => "and", :lval => @true_ast ).evaluate(@scope).should be_true
+    end
+
+end

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

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::CollExpr do
+
+    ast = Puppet::Parser::AST
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()        
+    end
+    
+    describe "when evaluating with two operands" do
+        before :each do
+            @test1 = mock 'test1'
+            @test1.expects(:safeevaluate).with(@scope).returns("test1")
+            @test2 = mock 'test2'
+            @test2.expects(:safeevaluate).with(@scope).returns("test2")
+        end
+
+        it "should evaluate both" do
+            collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper=>"==")
+            collexpr.evaluate(@scope)
+        end
+
+        it "should produce a textual representation and code of the expression" do
+            collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper=>"==")
+            result = collexpr.evaluate(@scope)
+            result[0].should == "param_values.value = 'test2' and param_names.name = 'test1'"
+            result[1].should be_an_instance_of(Proc)
+        end
+
+        it "should propagate expression type and form to child if expression themselves" do
+            [@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
+
+        describe "and when evaluating the produced code" do
+            before :each 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")
+            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")
+            end
+        end
+
+        it "should warn if this is an exported collection containing parenthesis (unsupported)" do
+            collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper=>"==", :parens => true, :form => :exported)
+            Puppet.expects(:warning)
+            collexpr.evaluate(@scope)
+        end
+
+        %w{and or}.each do |op|
+            it "should raise an error if this is an exported collection with #{op} operator (unsupported)" do
+                collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper=> op, :form => :exported)
+                lambda { collexpr.evaluate(@scope) }.should raise_error(Puppet::ParseError)
+            end
+        end
+    end
+    
+    it "should check for array member equality if resource parameter is an array for ==" 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.evaluate(@scope)[1].call(resource).should be_true
+    end
+
+    it "should raise an error for invalid operator" do
+        lambda { collexpr = ast::CollExpr.new(:oper=>">") }.should raise_error
+    end
+
+end

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

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::ComparisonOperator do
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+        @one = stub 'one', :safeevaluate => "1"
+        @two = stub 'two', :safeevaluate => "2"
+    end
+
+    it "should evaluate both branches" do
+        lval = stub "lval"
+        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
+
+    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
+    end
+
+    it "should fail with arguments of different types" do
+        lval = stub 'one', :safeevaluate => "one"
+        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
+
+    %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
+
+    it "should return the result of using '!=' to compare the left and right sides" do
+        operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => '!=', :rval => @two
+
+        operator.evaluate(@scope).should == true
+    end
+
+    it "should work for variables too" do
+        one = Puppet::Parser::AST::Variable.new( :value => "one" )
+        two = Puppet::Parser::AST::Variable.new( :value => "two" )
+
+        @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
+
+    # see ticket #1759
+    %w{< > <= >=}.each do |oper|
+        it "should return the correct result of using '#{oper}' to compare 10 and 9" 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
+
+end