puppet 0.24.6 → 0.24.7

data/spec/unit/parser/parser.rb

@@ -0,0 +1,228 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Parser do
+
+    ast = Puppet::Parser::AST
+
+    before :each do
+        @parser = Puppet::Parser::Parser.new :environment => "development"
+        @true_ast = Puppet::Parser::AST::Boolean.new :value => true
+    end
+
+    describe "when parsing append operator" do
+
+        it "should not raise syntax errors" do
+            lambda { @parser.parse("$var += something") }.should_not raise_error
+        end
+
+        it "shouldraise syntax error on incomplete syntax " do
+            lambda { @parser.parse("$var += ") }.should raise_error
+        end
+
+        it "should call ast::VarDef with append=true" do
+            ast::VarDef.expects(:new).with { |h| h[:append] == true }
+            @parser.parse("$var += 2")
+        end
+
+        it "should work with arrays too" do
+            ast::VarDef.expects(:new).with { |h| h[:append] == true }
+            @parser.parse("$var += ['test']")
+        end
+
+    end
+
+    describe Puppet::Parser, "when parsing 'if'" do
+        it "not, it should create the correct ast objects" do
+            ast::Not.expects(:new).with { |h| h[:value].is_a?(ast::Boolean) }
+            @parser.parse("if ! true { $var = 1 }")
+        end
+
+        it "boolean operation, it should create the correct ast objects" do
+            ast::BooleanOperator.expects(:new).with { 
+                |h| h[:rval].is_a?(ast::Boolean) and h[:lval].is_a?(ast::Boolean) and h[:operator]=="or"
+            }
+            @parser.parse("if true or true { $var = 1 }")
+
+        end
+
+        it "comparison operation, it should create the correct ast objects" do
+             ast::ComparisonOperator.expects(:new).with { 
+                 |h| h[:lval].is_a?(ast::Name) and h[:rval].is_a?(ast::Name) and h[:operator]=="<"
+             }
+             @parser.parse("if 1 < 2 { $var = 1 }")
+
+        end
+
+    end
+
+    describe Puppet::Parser, "when parsing if complex expressions" do
+         it "should create a correct ast tree" do
+             aststub = stub_everything 'ast'
+             ast::ComparisonOperator.expects(:new).with { 
+                 |h| h[:rval].is_a?(ast::Name) and h[:lval].is_a?(ast::Name) and h[:operator]==">"
+             }.returns(aststub)
+             ast::ComparisonOperator.expects(:new).with { 
+                 |h| h[:rval].is_a?(ast::Name) and h[:lval].is_a?(ast::Name) and h[:operator]=="=="
+             }.returns(aststub)
+             ast::BooleanOperator.expects(:new).with {
+                 |h| h[:rval]==aststub and h[:lval]==aststub and h[:operator]=="and"
+             }
+             @parser.parse("if (1 > 2) and (1 == 2) { $var = 1 }")
+         end
+
+         it "should raise an error on incorrect expression" do
+             lambda { @parser.parse("if (1 > 2 > ) or (1 == 2) { $var = 1 }") }.should raise_error
+        end
+
+    end
+
+    describe Puppet::Parser, "when parsing resource references" do
+        
+        it "should not raise syntax errors" do
+            lambda { @parser.parse('exec { test: param => File["a"] }') }.should_not raise_error
+        end
+
+        it "should not raise syntax errors with multiple references" do
+            lambda { @parser.parse('exec { test: param => File["a","b"] }') }.should_not raise_error
+        end
+        
+        it "should create an ast::ResourceReference" do
+            ast::Resource.stubs(:new)
+            ast::ResourceReference.expects(:new).with { |arg| 
+                arg[:line]==1 and arg[:type]=="File" and arg[:title].is_a?(ast::ASTArray)
+            }
+            @parser.parse('exec { test: command => File["a","b"] }')
+        end
+    end
+     
+    describe Puppet::Parser, "when parsing resource overrides" do
+        
+        it "should not raise syntax errors" do
+            lambda { @parser.parse('Resource["title"] { param => value }') }.should_not raise_error
+        end
+
+        it "should not raise syntax errors with multiple overrides" do
+            lambda { @parser.parse('Resource["title1","title2"] { param => value }') }.should_not raise_error
+        end
+
+        it "should create an ast::ResourceOverride" do
+            ast::ResourceOverride.expects(:new).with { |arg| 
+                arg[:line]==1 and arg[:object].is_a?(ast::ResourceReference) and arg[:params].is_a?(ast::ResourceParam)
+            }
+            @parser.parse('Resource["title1","title2"] { param => value }')
+        end
+        
+    end
+     
+    describe Puppet::Parser, "when parsing if statements" do
+
+        it "should not raise errors with empty if" do
+            lambda { @parser.parse("if true { }") }.should_not raise_error
+        end
+
+        it "should not raise errors with empty else" do
+            lambda { @parser.parse("if false { notice('if') } else { }") }.should_not raise_error
+        end
+
+        it "should not raise errors with empty if and else" do
+            lambda { @parser.parse("if false { } else { }") }.should_not raise_error
+        end
+
+        it "should create a nop node for empty branch" do
+            ast::Nop.expects(:new)
+            @parser.parse("if true { }")
+        end
+
+        it "should create a nop node for empty else branch" do
+            ast::Nop.expects(:new)
+            @parser.parse("if true { notice('test') } else { }")
+        end
+
+    end
+
+    describe Puppet::Parser, "when parsing function calls" do
+
+        it "should not raise errors with no arguments" do
+            lambda { @parser.parse("tag()") }.should_not raise_error
+        end
+
+        it "should not raise errors with rvalue function with no args" do
+            lambda { @parser.parse("$a = template()") }.should_not raise_error
+        end
+
+        it "should not raise errors with arguments" do
+            lambda { @parser.parse("notice(1)") }.should_not raise_error
+        end
+
+        it "should not raise errors with multiple arguments" do
+            lambda { @parser.parse("notice(1,2)") }.should_not raise_error
+        end
+
+        it "should not raise errors with multiple arguments and a trailing comma" do
+            lambda { @parser.parse("notice(1,2,)") }.should_not raise_error
+		end
+
+	end
+
+	describe Puppet::Parser, "when parsing arrays with trailing comma" do
+
+        it "should not raise errors with a trailing comma" do
+            lambda { @parser.parse("$a = [1,2,]") }.should_not raise_error
+        end
+    end
+            
+    describe Puppet::Parser, "when instantiating class of same name" do
+
+        before :each do
+            @one = stub 'one', :is_a? => true
+            @one.stubs(:is_a?).with(ast::ASTArray).returns(false)
+            @one.stubs(:is_a?).with(ast).returns(true)
+
+            @two = stub 'two'
+            @two.stubs(:is_a?).with(ast::ASTArray).returns(false)
+            @two.stubs(:is_a?).with(ast).returns(true)
+        end
+
+        it "should return the first class" do
+
+            klass1 = @parser.newclass("one", { :code => @one })
+
+            @parser.newclass("one", { :code => @two }).should == klass1
+        end
+
+        it "should concatenate code" do
+            klass1 = @parser.newclass("one", { :code => @one })
+
+            @parser.newclass("one", { :code => @two })
+
+            klass1.code.children.should == [@one,@two]
+        end
+    end
+
+    describe Puppet::Parser, "when parsing comments before statement" do
+        it "should associate the documentation to the statement AST node" do
+            ast = @parser.parse("""
+            # comment
+            class test {}
+            """)
+
+            ast[:classes]["test"].doc.should == "comment\n"
+        end
+    end
+
+    describe Puppet::Parser, "when building ast nodes" do
+        it "should get lexer comments if ast node declares use_docs" do
+            lexer = stub 'lexer'
+            ast = mock 'ast', :nil? => false, :use_docs => true, :doc => ""
+            @parser.stubs(:lexer).returns(lexer)
+
+            Puppet::Parser::AST::Definition.expects(:new).returns(ast)
+            lexer.expects(:getcomment).returns("comment")
+            ast.expects(:doc=).with("comment")
+
+            @parser.ast(Puppet::Parser::AST::Definition)
+        end
+    end
+ end

data/spec/unit/parser/resource.rb

@@ -0,0 +1,336 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+# LAK: FIXME This is just new tests for resources; I have
+# not moved all tests over yet.
+
+describe Puppet::Parser::Resource do
+    before do
+        @parser = Puppet::Parser::Parser.new :Code => ""
+        @source = @parser.newclass ""
+        @node = Puppet::Node.new("yaynode")
+        @compiler = Puppet::Parser::Compiler.new(@node, @parser)
+        @scope = @compiler.topscope
+    end
+
+    def mkresource(args = {})
+        args[:source] ||= "source"
+        args[:scope] ||= stub('scope', :source => mock('source'))
+
+        {:type => "resource", :title => "testing", :source => "source", :scope => "scope"}.each do |param, value|
+            args[param] ||= value
+        end
+
+        params = args[:params] || {:one => "yay", :three => "rah"}
+        if args[:params] == :none
+            args.delete(:params)
+        else
+            args[:params] = paramify(args[:source], params)
+        end
+
+        Puppet::Parser::Resource.new(args)
+    end
+
+    def param(name, value, source)
+        Puppet::Parser::Resource::Param.new(:name => name, :value => value, :source => source)
+    end
+
+    def paramify(source, hash)
+        hash.collect do |name, value|
+            Puppet::Parser::Resource::Param.new(
+                :name => name, :value => value, :source => source
+            )
+        end
+    end
+
+    it "should be isomorphic if it is builtin and models an isomorphic type" do
+        Puppet::Type.type(:file).expects(:isomorphic?).returns(true)
+        @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
+    end
+
+    it "should not be isomorphic if it is builtin and models a non-isomorphic type" do
+        Puppet::Type.type(:file).expects(:isomorphic?).returns(false)
+        @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_false
+    end
+
+    it "should be isomorphic if it is not builtin" do
+        @parser.newdefine "whatever"
+        @resource = Puppet::Parser::Resource.new(:type => "whatever", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
+    end
+
+    it "should have a array-indexing method for retrieving parameter values" do
+        @resource = mkresource
+        @resource[:one].should == "yay"
+    end
+
+    it "should have a method for converting to a ral resource" do
+        trans = mock 'trans', :to_type => "yay"
+        @resource = mkresource
+        @resource.expects(:to_trans).returns trans
+        @resource.to_type.should == "yay"
+    end
+
+    describe "when initializing" do
+        before do
+            @arguments = {:type => "resource", :title => "testing", :scope => stub('scope', :source => mock('source'))}
+        end
+
+        [:type, :title, :scope].each do |name|
+            it "should fail unless #{name.to_s} is specified" do
+                try = @arguments.dup
+                try.delete(name)
+                lambda { Puppet::Parser::Resource.new(try) }.should raise_error(ArgumentError)
+            end
+        end
+
+        it "should set the reference correctly" do
+            res = Puppet::Parser::Resource.new(@arguments)
+            res.ref.should == "Resource[testing]"
+        end
+    end
+
+    describe "when evaluating" do
+        before do
+            @type = Puppet::Parser::Resource
+
+            @definition = @parser.newdefine "mydefine"
+            @class = @parser.newclass "myclass"
+            @nodedef = @parser.newnode("mynode")[0]
+        end
+
+        it "should evaluate the associated AST definition" do
+            res = @type.new(:type => "mydefine", :title => "whatever", :scope => @scope, :source => @source)
+            @definition.expects(:evaluate_code).with(res)
+
+            res.evaluate
+        end
+
+        it "should evaluate the associated AST class" do
+            res = @type.new(:type => "class", :title => "myclass", :scope => @scope, :source => @source)
+            @class.expects(:evaluate_code).with(res)
+            res.evaluate
+        end
+
+        it "should evaluate the associated AST node" do
+            res = @type.new(:type => "node", :title => "mynode", :scope => @scope, :source => @source)
+            @nodedef.expects(:evaluate_code).with(res)
+            res.evaluate
+        end
+    end
+
+    describe "when finishing" do
+        before do
+            @class = @parser.newclass "myclass"
+            @nodedef = @parser.newnode("mynode")[0]
+
+            @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source)
+        end
+
+        it "should do nothing if it has already been finished" do
+            @resource.finish
+            @resource.expects(:add_metaparams).never
+            @resource.finish
+        end
+
+        it "should add all defaults available from the scope" do
+            @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => param(:owner, "default", @resource.source))
+            @resource.finish
+
+            @resource[:owner].should == "default"
+        end
+
+        it "should not replace existing parameters with defaults" do
+            @resource.set_parameter :owner, "oldvalue"
+            @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => :replaced)
+            @resource.finish
+
+            @resource[:owner].should == "oldvalue"
+        end
+
+        it "should add a copy of each default, rather than the actual default parameter instance" do
+            newparam = param(:owner, "default", @resource.source)
+            other = newparam.dup
+            other.value = "other"
+            newparam.expects(:dup).returns(other)
+            @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => newparam)
+            @resource.finish
+
+            @resource[:owner].should == "other"
+        end
+
+        it "should copy metaparams from its scope" do
+            @scope.setvar("noop", "true")
+
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+
+            @resource["noop"].should == "true"
+        end
+
+        it "should not copy metaparams that it already has" do
+            @resource.set_parameter("noop", "false")
+            @scope.setvar("noop", "true")
+
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+
+            @resource["noop"].should == "false"
+        end
+
+        it "should copy all metaparams that it finds" do
+            @scope.setvar("require", "container")
+            @scope.setvar("notify", "container")
+
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+
+            @resource["require"].should == "container"
+            @resource["notify"].should == "container"
+        end
+
+        it "should stack relationship metaparams from its container if it already has them" do
+            @resource.set_parameter("require", "resource")
+            @scope.setvar("require", "container")
+
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+
+            @resource["require"].sort.should == %w{container resource}
+        end
+
+        it "should flatten the array resulting from stacking relationship metaparams" do
+            @resource.set_parameter("require", ["resource1", "resource2"])
+            @scope.setvar("require", %w{container1 container2})
+
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+
+            @resource["require"].sort.should == %w{container1 container2 resource1 resource2}
+        end
+
+        it "should add any tags from the scope resource" do
+            scope_resource = stub 'scope_resource', :tags => %w{one two}
+            @scope.stubs(:resource).returns(scope_resource)
+
+            @resource.class.publicize_methods(:add_scope_tags)  { @resource.add_scope_tags }
+
+            @resource.tags.should be_include("one")
+            @resource.tags.should be_include("two")
+        end
+    end
+
+    describe "when being tagged" do
+        before do
+            @scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
+            @scope = stub 'scope', :resource => @scope_resource
+            @resource = Puppet::Parser::Resource.new(:type => "file", :title => "yay", :scope => @scope, :source => mock('source'))
+        end
+
+        it "should get tagged with the resource type" do
+            @resource.tags.should be_include("file")
+        end
+
+        it "should get tagged with the title" do
+            @resource.tags.should be_include("yay")
+        end
+
+        it "should get tagged with each name in the title if the title is a qualified class name" do
+            resource = Puppet::Parser::Resource.new(:type => "file", :title => "one::two", :scope => @scope, :source => mock('source'))
+            resource.tags.should be_include("one")
+            resource.tags.should be_include("two")
+        end
+
+        it "should get tagged with each name in the type if the type is a qualified class name" do
+            resource = Puppet::Parser::Resource.new(:type => "one::two", :title => "whatever", :scope => @scope, :source => mock('source'))
+            resource.tags.should be_include("one")
+            resource.tags.should be_include("two")
+        end
+
+        it "should not get tagged with non-alphanumeric titles" do
+            resource = Puppet::Parser::Resource.new(:type => "file", :title => "this is a test", :scope => @scope, :source => mock('source'))
+            resource.tags.should_not be_include("this is a test")
+        end
+
+        it "should fail on tags containing '*' characters" do
+            lambda { @resource.tag("bad*tag") }.should raise_error(Puppet::ParseError)
+        end
+
+        it "should fail on tags starting with '-' characters" do
+            lambda { @resource.tag("-badtag") }.should raise_error(Puppet::ParseError)
+        end
+
+        it "should fail on tags containing ' ' characters" do
+            lambda { @resource.tag("bad tag") }.should raise_error(Puppet::ParseError)
+        end
+
+        it "should allow alpha tags" do
+            lambda { @resource.tag("good_tag") }.should_not raise_error(Puppet::ParseError)
+        end
+    end
+
+    describe "when merging overrides" do
+        before do
+            @source = "source1"
+            @resource = mkresource :source => @source
+            @override = mkresource :source => @source
+        end
+
+        it "should fail when the override was not created by a parent class" do
+            @override.source = "source2"
+            @override.source.expects(:child_of?).with("source1").returns(false)
+            lambda { @resource.merge(@override) }.should raise_error(Puppet::ParseError)
+        end
+
+        it "should succeed when the override was created in the current scope" do
+            @resource.source = "source3"
+            @override.source = @resource.source
+            @override.source.expects(:child_of?).with("source3").never
+            params = {:a => :b, :c => :d}
+            @override.expects(:params).returns(params)
+            @resource.expects(:override_parameter).with(:b)
+            @resource.expects(:override_parameter).with(:d)
+            @resource.merge(@override)
+        end
+
+        it "should succeed when a parent class created the override" do
+            @resource.source = "source3"
+            @override.source = "source4"
+            @override.source.expects(:child_of?).with("source3").returns(true)
+            params = {:a => :b, :c => :d}
+            @override.expects(:params).returns(params)
+            @resource.expects(:override_parameter).with(:b)
+            @resource.expects(:override_parameter).with(:d)
+            @resource.merge(@override)
+        end
+
+        it "should add new parameters when the parameter is not set" do
+            @source.stubs(:child_of?).returns true
+            @override.set_parameter(:testing, "value")
+            @resource.merge(@override)
+
+            @resource[:testing].should == "value"
+        end
+
+        it "should replace existing parameter values" do
+            @source.stubs(:child_of?).returns true
+            @resource.set_parameter(:testing, "old")
+            @override.set_parameter(:testing, "value")
+
+            @resource.merge(@override)
+
+            @resource[:testing].should == "value"
+        end
+
+        it "should add values to the parameter when the override was created with the '+>' syntax" do
+            @source.stubs(:child_of?).returns true
+            param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "testing", :source => @resource.source)
+            param.add = true
+
+            @override.set_parameter(param)
+
+            @resource.set_parameter(:testing, "other")
+
+            @resource.merge(@override)
+
+            @resource[:testing].should == %w{other testing}
+        end
+
+
+    end
+end