puppet 0.24.9 → 0.25.0

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

@@ -29,6 +29,24 @@ describe Puppet::Parser::AST::Definition, "when evaluating" do
         @definition.evaluate_code(@resource)
     end
 
+    it "should have a get_classname method" do
+        @definition.should respond_to(:get_classname)
+    end
+
+    it "should return the current classname with get_classname" do
+        @definition.expects(:classname)
+
+        @definition.get_classname(@scope)
+    end
+
+    describe "when evaluating" do
+        it "should create a resource whose title comes from get_classname" do
+            @definition.expects(:get_classname).returns("classname")
+
+            @definition.evaluate(@scope)
+        end
+    end
+
 #    it "should copy its namespace to the scope"
 #
 #    it "should mark the scope virtual if the resource is virtual"

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

@@ -16,6 +16,12 @@ describe Puppet::Parser::AST::Function do
         end
     end
 
+    it "should return its representation with to_s" do
+        args = stub 'args', :is_a? => true, :to_s => "[a, b]"
+
+        Puppet::Parser::AST::Function.new(:name => "func", :arguments => args).to_s.should == "func(a, b)"
+    end
+
     describe "when evaluating" do
 
         it "should fail if the function doesn't exist" do

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

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::IfStatement 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)
+
+            @stmt = stub 'stmt'
+            @stmt.stubs(:safeevaluate).with(@scope)
+
+            @else = stub 'else'
+            @else.stubs(:safeevaluate).with(@scope)
+
+            @ifstmt = Puppet::Parser::AST::IfStatement.new :test => @test, :statements => @stmt
+            @ifelsestmt = Puppet::Parser::AST::IfStatement.new :test => @test, :statements => @stmt, :else => @else
+        end
+
+        it "should evaluate test" do
+            Puppet::Parser::Scope.stubs(:true?).returns(false)
+
+            @test.expects(:safeevaluate).with(@scope)
+
+            @ifstmt.evaluate(@scope)
+        end
+
+        it "should evaluate if statements if test is true" do
+            Puppet::Parser::Scope.stubs(:true?).returns(true)
+
+            @stmt.expects(:safeevaluate).with(@scope)
+
+            @ifstmt.evaluate(@scope)
+        end
+
+        it "should not evaluate if statements if test is false" do
+            Puppet::Parser::Scope.stubs(:true?).returns(false)
+
+            @stmt.expects(:safeevaluate).with(@scope).never
+
+            @ifstmt.evaluate(@scope)
+        end
+
+        it "should evaluate the else branch if test is false" do
+            Puppet::Parser::Scope.stubs(:true?).returns(false)
+
+            @else.expects(:safeevaluate).with(@scope)
+
+            @ifelsestmt.evaluate(@scope)
+        end
+
+        it "should not evaluate the else branch if test is true" do
+            Puppet::Parser::Scope.stubs(:true?).returns(true)
+
+            @else.expects(:safeevaluate).with(@scope).never
+
+            @ifelsestmt.evaluate(@scope)
+        end
+
+        it "should reset ephemeral statements after evaluation" do
+            Puppet::Parser::Scope.stubs(:true?).returns(true)
+
+            @stmt.expects(:safeevaluate).with(@scope)
+            @scope.expects(:unset_ephemeral_var)
+
+            @ifstmt.evaluate(@scope)
+        end
+    end
+end

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

@@ -0,0 +1,261 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Leaf do
+    before :each do
+        @scope = stub 'scope'
+        @value = stub 'value'
+        @leaf = Puppet::Parser::AST::Leaf.new(:value => @value)
+    end
+
+    it "should have a evaluate_match method" do
+        Puppet::Parser::AST::Leaf.new(:value => "value").should respond_to(:evaluate_match)
+    end
+
+    describe "when evaluate_match is called" do
+        it "should evaluate itself" do
+            @leaf.expects(:safeevaluate).with(@scope)
+
+            @leaf.evaluate_match("value", @scope)
+        end
+
+        it "should match values by equality" do
+            @leaf.stubs(:safeevaluate).with(@scope).returns(@value)
+            @value.expects(:==).with("value")
+
+            @leaf.evaluate_match("value", @scope)
+        end
+
+        it "should downcase the evaluated value if wanted" do
+            @leaf.stubs(:safeevaluate).with(@scope).returns(@value)
+            @value.expects(:downcase).returns("value")
+
+            @leaf.evaluate_match("value", @scope, :insensitive => true)
+        end
+    end
+
+    describe "when converting to string" do
+        it "should transform its value to string" do
+            value = stub 'value', :is_a? => true
+            value.expects(:to_s)
+            Puppet::Parser::AST::Leaf.new( :value => value ).to_s
+        end
+    end
+
+    it "should have a match method" do
+        @leaf.should respond_to(:match)
+    end
+
+    it "should delegate match to ==" do
+        @value.expects(:==).with("value")
+
+        @leaf.match("value")
+    end
+end
+
+describe Puppet::Parser::AST::FlatString do
+    describe "when converting to string" do
+        it "should transform its value to a quoted string" do
+            value = stub 'value', :is_a? => true, :to_s => "ab"
+            Puppet::Parser::AST::FlatString.new( :value => value ).to_s.should == "\"ab\""
+        end
+    end
+end
+
+describe Puppet::Parser::AST::String do
+    describe "when converting to string" do
+        it "should transform its value to a quoted string" do
+            value = stub 'value', :is_a? => true, :to_s => "ab"
+            Puppet::Parser::AST::String.new( :value => value ).to_s.should == "\"ab\""
+        end
+    end
+end
+
+describe Puppet::Parser::AST::Regex do
+    before :each do
+        @scope = stub 'scope'
+    end
+
+    describe "when initializing" do
+        it "should create a Regexp with its content when value is not a Regexp" do
+            Regexp.expects(:new).with("/ab/")
+
+            Puppet::Parser::AST::Regex.new :value => "/ab/"
+        end
+
+        it "should not create a Regexp with its content when value is a Regexp" do
+            value = Regexp.new("/ab/")
+            Regexp.expects(:new).with("/ab/").never
+
+            Puppet::Parser::AST::Regex.new :value => value
+        end
+    end
+
+    describe "when evaluating" do
+        it "should return self" do
+            val = Puppet::Parser::AST::Regex.new :value => "/ab/"
+
+            val.evaluate(@scope).should === val
+        end
+    end
+
+    describe "when evaluate_match" do
+        before :each do
+            @value = stub 'regex'
+            @value.stubs(:match).with("value").returns(true)
+            Regexp.stubs(:new).returns(@value)
+            @regex = Puppet::Parser::AST::Regex.new :value => "/ab/"
+        end
+
+        it "should issue the regexp match" do
+            @value.expects(:match).with("value")
+
+            @regex.evaluate_match("value", @scope)
+        end
+
+        it "should set ephemeral scope vars if there is a match" do
+            @scope.expects(:ephemeral_from).with(true, nil, nil)
+
+            @regex.evaluate_match("value", @scope)
+        end
+
+        it "should return the match to the caller" do
+            @value.stubs(:match).with("value").returns(:match)
+            @scope.stubs(:ephemeral_from)
+
+            @regex.evaluate_match("value", @scope)
+        end
+    end
+
+    it "should return the regex source with to_s" do
+        regex = stub 'regex'
+        Regexp.stubs(:new).returns(regex)
+
+        val = Puppet::Parser::AST::Regex.new :value => "/ab/"
+
+        regex.expects(:source)
+
+        val.to_s
+    end
+
+    it "should delegate match to the underlying regexp match method" do
+        regex = Regexp.new("/ab/")
+        val = Puppet::Parser::AST::Regex.new :value => regex
+
+        regex.expects(:match).with("value")
+
+        val.match("value")
+    end
+end
+
+describe Puppet::Parser::AST::HostName do
+    before :each do
+        @scope = stub 'scope'
+        @value = stub 'value', :=~ => false
+        @value.stubs(:to_s).returns(@value)
+        @value.stubs(:downcase).returns(@value)
+        @host = Puppet::Parser::AST::HostName.new( :value => @value)
+    end
+
+    it "should raise an error if hostname is not valid" do
+        lambda { Puppet::Parser::AST::HostName.new( :value => "not an hostname!" ) }.should raise_error
+    end
+
+    it "should not raise an error if hostname is a regex" do
+        lambda { Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/test/") ) }.should_not raise_error
+    end
+
+    it "should stringify the value" do
+        value = stub 'value', :=~ => false
+
+        value.expects(:to_s).returns("test")
+
+        Puppet::Parser::AST::HostName.new(:value => value)
+    end
+
+    it "should downcase the value" do
+        value = stub 'value', :=~ => false
+        value.stubs(:to_s).returns("UPCASED")
+        host = Puppet::Parser::AST::HostName.new(:value => value)
+
+        host.value == "upcased"
+    end
+
+    it "should evaluate to its value" do
+        @host.evaluate(@scope).should == @value
+    end
+
+    it "should implement to_classname" do
+        @host.should respond_to(:to_classname)
+    end
+
+    it "should return the downcased nodename as classname" do
+        host = Puppet::Parser::AST::HostName.new( :value => "KLASSNAME" )
+        host.to_classname.should == "klassname"
+    end
+
+    it "should return a string usable as classname when calling to_classname" do
+        host = Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/^this-is not@a classname$/") )
+        host.to_classname.should == "this-isnotaclassname"
+    end
+
+    it "should delegate 'match' to the underlying value if it is an HostName" do
+        @value.expects(:match).with("value")
+        @host.match("value")
+    end
+
+    it "should delegate eql? to the underlying value if it is an HostName" do
+        @value.expects(:eql?).with("value")
+        @host.eql?("value")
+    end
+
+    it "should delegate eql? to the underlying value if it is not an HostName" do
+        value = stub 'compared', :is_a? => true, :value => "value"
+        @value.expects(:eql?).with("value")
+        @host.eql?(value)
+    end
+
+    it "should delegate hash to the underlying value" do
+        @value.expects(:hash)
+        @host.hash
+    end
+
+    it "should return true when regex? is called and value is a Regex" do
+        @value.expects(:is_a?).with(Puppet::Parser::AST::Regex).returns(true)
+        @host.regex?.should be_true
+    end
+
+    it "should return the results of comparing the regexes if asked whether a regex matches another regex" do
+        hosts = [1,2].collect do |num|
+            vreg = /vreg#{num}/
+            value = Puppet::Parser::AST::Regex.new(:value => vreg)
+            Puppet::Parser::AST::HostName.new(:value => value)
+        end
+
+        hosts[0].match(hosts[1]).should be_false
+        hosts[0].match(hosts[0]).should be_true
+    end
+
+    it "should return false when comparing a non-regex to a regex" do
+        vreg = /vreg/
+        value = Puppet::Parser::AST::Regex.new(:value => vreg)
+        regex = Puppet::Parser::AST::HostName.new(:value => value)
+
+        value = Puppet::Parser::AST::Regex.new(:value => "foo")
+        normal = Puppet::Parser::AST::HostName.new(:value => value)
+
+        normal.match(regex).should be_false
+    end
+
+    it "should true when a provided string matches a regex" do
+        vreg = /r/
+        value = Puppet::Parser::AST::Regex.new(:value => vreg)
+        regex = Puppet::Parser::AST::HostName.new(:value => value)
+
+        value = Puppet::Parser::AST::Leaf.new(:value => "bar")
+        normal = Puppet::Parser::AST::HostName.new(:value => value)
+
+        regex.match(normal).should be_true
+    end
+end

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

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::MatchOperator do
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+
+        @lval = stub 'lval'
+        @lval.stubs(:safeevaluate).with(@scope).returns("this is a string")
+
+        @rval = stub 'rval'
+        @rval.stubs(:evaluate_match)
+
+        @operator = Puppet::Parser::AST::MatchOperator.new :lval => @lval, :rval => @rval, :operator => "=~"
+    end
+
+    it "should evaluate the left operand" do
+        @lval.expects(:safeevaluate).with(@scope)
+
+        @operator.evaluate(@scope)
+    end
+
+    it "should fail for an unknown operator" do
+        lambda { operator = Puppet::Parser::AST::MatchOperator.new :lval => @lval, :operator => "unknown", :rval => @rval }.should raise_error
+    end
+
+    it "should evaluate_match the left operand" do
+        @rval.expects(:evaluate_match).with("this is a string", @scope).returns(:match)
+
+        @operator.evaluate(@scope)
+    end
+
+    { "=~" => true, "!~" => false }.each do |op, res|
+        it "should return #{res} if the regexp matches with #{op}" do
+            match = stub 'match'
+            @rval.stubs(:evaluate_match).with("this is a string", @scope).returns(match)
+
+            operator = Puppet::Parser::AST::MatchOperator.new :lval => @lval, :rval => @rval, :operator => op
+            operator.evaluate(@scope).should == res
+        end
+
+        it "should return #{!res} if the regexp doesn't match" do
+            @rval.stubs(:evaluate_match).with("this is a string", @scope).returns(nil)
+
+            operator = Puppet::Parser::AST::MatchOperator.new :lval => @lval, :rval => @rval, :operator => op
+            operator.evaluate(@scope).should == !res
+        end
+    end
+end

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

@@ -10,7 +10,7 @@ describe Puppet::Parser::AST::Minus do
     it "should evaluate its argument" do
         value = stub "value"
         value.expects(:safeevaluate).with(@scope).returns(123)
-        
+
         operator = Puppet::Parser::AST::Minus.new :value => value
         operator.evaluate(@scope)
     end

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

@@ -12,6 +12,26 @@ describe Puppet::Parser::AST::Node do
         @scope = @compiler.topscope
     end
 
+    describe "when calling get_classname" do
+        it "should return current node name if name is a Regex" do
+            name = stub 'name', :regex? => true
+            node = @parser.newnode("node").shift
+            node.stubs(:name).returns(name)
+
+            @scope.expects(:host).returns("testnode")
+
+            node.get_classname(@scope).should == "testnode"
+        end
+
+        it "should return the current node classname if name is not a Regex" do
+            name = stub 'name', :regex? => false
+            node = @parser.newnode("node").shift
+            node.stubs(:name).returns(name)
+
+            node.get_classname(@scope).should == "node"
+        end
+    end
+
     describe Puppet::Parser::AST::Node, "when evaluating" do
 
         before do