puppet 0.18.4 → 0.22.4

data/test/language/ast/casestatement.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2006-12-22.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppettest/parsertesting'
+
+class TestCaseStatement < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::ParserTesting
+	AST = Puppet::Parser::AST
+	
+	class ActiveAST < FakeAST
+	    def self.clear
+	        $evaluated = []
+        end
+	    def evaluate
+	        $evaluated ||= []
+	        $evaluated << @evaluate
+        end
+    end
+	
+	def test_evaluate
+        ast = nil
+        scope = mkscope
+        param = nameobj("MyParam")
+
+        hash = {
+            "myparam" => ActiveAST.new("lower"),
+            "MyParam" => ActiveAST.new("upper"),
+            true => ActiveAST.new(true)
+        }
+        options = ["myparam", "MyParam"].collect do |p|
+            AST::CaseOpt.new(:value => FakeAST.new(p), :statements => hash[p])
+        end
+        assert_nothing_raised do
+            ast = AST::CaseStatement.new(:test => param, :options => options)
+        end
+
+        # Start out case-sensitive
+        Puppet[:casesensitive] = true
+
+        result = nil
+        assert_nothing_raised do
+            result = ast.evaluate :scope => scope
+        end
+        assert(result, "did not get valid result")
+        assert_equal(["upper"], $evaluated, "Did not match case-sensitively")
+        assert(! hash["myparam"].evaluated?, "lower value was evaluated even though it did not match")
+
+        # Now try it case-insensitive
+        Puppet[:casesensitive] = false
+        $evaluated.clear
+        hash["MyParam"].reset
+        assert_nothing_raised do
+            result = ast.evaluate :scope => scope
+        end
+        assert(result, "did not get valid result")
+        assert_equal(["lower"], result, "Did not match case-insensitively")
+        assert(! hash["MyParam"].evaluated?, "upper value was evaluated even though it did not match")
+    end
+
+    # #522 - test that case statements with multiple values work as
+    # expected, where any true value suffices.
+    def test_multiple_values
+        ast = nil
+
+        tests = {
+            "one" => %w{a b c},
+            "two" => %w{e f g}
+        }
+        options = tests.collect do |result, values|
+            values = values.collect { |v| AST::Leaf.new :value => v }
+            AST::CaseOpt.new(:value => AST::ASTArray.new(:children => values),
+                :statements => AST::Leaf.new(:value => result))
+        end
+        options << AST::CaseOpt.new(:value => AST::Default.new(:value => "default"),
+            :statements => AST::Leaf.new(:value => "default"))
+
+        ast = nil
+        param = AST::Variable.new(:value => "testparam")
+        assert_nothing_raised do
+            ast = AST::CaseStatement.new(:test => param, :options => options)
+        end
+        result = nil
+        tests.each do |should, values|
+            values.each do |value|
+                result = nil
+                scope = mkscope
+                scope.setvar("testparam", value)
+                assert_nothing_raised do
+                    result = ast.evaluate(:scope => scope)
+                end
+
+                assert_equal(should, result, "Got incorrect result for %s" % value)
+            end
+        end
+    end
+end
+
+# $Id: casestatement.rb 2231 2007-02-27 21:31:02Z luke $

data/test/language/ast/component.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2006-02-20.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'mocha'
+require 'puppettest/parsertesting'
+require 'puppettest/resourcetesting'
+
+class TestASTComponent < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
+	AST = Puppet::Parser::AST
+
+    def test_component
+        interp, scope, source = mkclassframing
+
+        # Create a new definition
+        klass = interp.newdefine "yayness",
+            :arguments => [["owner", stringobj("nobody")], %w{mode}],
+            :code => AST::ASTArray.new(
+                :children => [resourcedef("file", "/tmp/$name",
+                        "owner" => varref("owner"), "mode" => varref("mode"))]
+            )
+
+        # Test validattr? a couple different ways
+        [:owner, "owner", :schedule, "schedule"].each do |var|
+            assert(klass.validattr?(var), "%s was not considered valid" % var.inspect)
+        end
+
+        [:random, "random"].each do |var|
+            assert(! klass.validattr?(var), "%s was considered valid" % var.inspect)
+        end
+        # Now call it a couple of times
+        # First try it without a required param
+        assert_raise(Puppet::ParseError) do
+            klass.evaluate(:scope => scope,
+                :name => "bad",
+                :arguments => {"owner" => "nobody"}
+            )
+        end
+
+        # And make sure it didn't create the file
+        assert_nil(scope.findresource("File[/tmp/bad]"),
+            "Made file with invalid params")
+
+        assert_nothing_raised do
+            klass.evaluate(:scope => scope,
+                :title => "first",
+                :arguments => {"mode" => "755"}
+            )
+        end
+
+        firstobj = scope.findresource("File[/tmp/first]")
+        assert(firstobj, "Did not create /tmp/first obj")
+
+        assert_equal("file", firstobj.type)
+        assert_equal("/tmp/first", firstobj.title)
+        assert_equal("nobody", firstobj[:owner])
+        assert_equal("755", firstobj[:mode])
+
+        # Make sure we can't evaluate it with the same args
+        assert_raise(Puppet::ParseError) do
+            klass.evaluate(:scope => scope,
+                :title => "first",
+                :arguments => {"mode" => "755"}
+            )
+        end
+
+        # Now create another with different args
+        assert_nothing_raised do
+            klass.evaluate(:scope => scope,
+                :title => "second",
+                :arguments => {"mode" => "755", "owner" => "daemon"}
+            )
+        end
+
+        secondobj = scope.findresource("File[/tmp/second]")
+        assert(secondobj, "Did not create /tmp/second obj")
+
+        assert_equal("file", secondobj.type)
+        assert_equal("/tmp/second", secondobj.title)
+        assert_equal("daemon", secondobj[:owner])
+        assert_equal("755", secondobj[:mode])
+    end
+
+    # #539 - definitions should support both names and titles
+    def test_names_and_titles
+        interp, scope, source = mkclassframing
+
+        [
+        {:name => "one", :title => "two"},
+        {:title => "mytitle"},
+        ].each_with_index do |hash, i|
+
+            # Create a definition that uses both name and title
+            klass = interp.newdefine "yayness%s" % i
+
+            subscope = klass.subscope(scope, "yayness%s" % i)
+
+            klass.expects(:subscope).returns(subscope)
+
+            args = {:title => hash[:title]}
+            if hash[:name]
+                args[:arguments] = {:name => hash[:name]}
+            end
+            args[:scope] = scope
+            assert_nothing_raised("Could not evaluate definition with %s" % hash.inspect) do
+                klass.evaluate(args)
+            end
+
+            name = hash[:name] || hash[:title]
+            title = hash[:title]
+            args[:name] ||= name
+
+            assert_equal(name, subscope.lookupvar("name"),
+                "Name did not get set correctly")
+            assert_equal(title, subscope.lookupvar("title"),
+                "title did not get set correctly")
+
+            [:name, :title].each do |param|
+                val = args[param]
+                assert(subscope.tags.include?(val),
+                    "Scope was not tagged with %s" % val)
+            end
+        end
+    end
+end
+# $Id: component.rb 2301 2007-03-19 00:46:25Z luke $

data/test/language/ast/hostclass.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2006-02-20.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppettest/parsertesting'
+require 'puppettest/resourcetesting'
+
+class TestASTHostClass < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
+	AST = Puppet::Parser::AST
+
+    def test_hostclass
+        interp, scope, source = mkclassframing
+
+        # Create the class we're testing, first with no parent
+        klass = interp.newclass "first",
+            :code => AST::ASTArray.new(
+                :children => [resourcedef("file", "/tmp",
+                        "owner" => "nobody", "mode" => "755")]
+            )
+
+        assert_nothing_raised do
+            klass.evaluate(:scope => scope)
+        end
+
+        # Then try it again
+        assert_nothing_raised do
+            klass.evaluate(:scope => scope)
+        end
+
+        assert(scope.setclass?(klass), "Class was not considered evaluated")
+
+        tmp = scope.findresource("File[/tmp]")
+        assert(tmp, "Could not find file /tmp")
+        assert_equal("nobody", tmp[:owner])
+        assert_equal("755", tmp[:mode])
+
+        # Now create a couple more classes.
+        newbase = interp.newclass "newbase",
+            :code => AST::ASTArray.new(
+                :children => [resourcedef("file", "/tmp/other",
+                        "owner" => "nobody", "mode" => "644")]
+            )
+
+        newsub = interp.newclass "newsub",
+            :parent => "newbase",
+            :code => AST::ASTArray.new(
+                :children => [resourcedef("file", "/tmp/yay",
+                        "owner" => "nobody", "mode" => "755"),
+                    resourceoverride("file", "/tmp/other",
+                            "owner" => "daemon")
+                ]
+            )
+
+        # Override a different variable in the top scope.
+        moresub = interp.newclass "moresub",
+            :parent => "newbase",
+            :code => AST::ASTArray.new(
+                :children => [resourceoverride("file", "/tmp/other",
+                            "mode" => "755")]
+            )
+
+        assert_nothing_raised do
+            newsub.evaluate(:scope => scope)
+        end
+
+        assert_nothing_raised do
+            moresub.evaluate(:scope => scope)
+        end
+
+        assert(scope.setclass?(newbase), "Did not eval newbase")
+        assert(scope.setclass?(newsub), "Did not eval newsub")
+
+        yay = scope.findresource("File[/tmp/yay]")
+        assert(yay, "Did not find file /tmp/yay")
+        assert_equal("nobody", yay[:owner])
+        assert_equal("755", yay[:mode])
+
+        other = scope.findresource("File[/tmp/other]")
+        assert(other, "Did not find file /tmp/other")
+        assert_equal("daemon", other[:owner])
+        assert_equal("755", other[:mode])
+    end
+
+    # Make sure that classes set their namespaces to themselves.  This
+    # way they start looking for definitions in their own namespace.
+    def test_hostclass_namespace
+        interp, scope, source = mkclassframing
+
+        # Create a new class
+        klass = nil
+        assert_nothing_raised do
+            klass = interp.newclass "funtest"
+        end
+
+        # Now define a definition in that namespace
+
+        define = nil
+        assert_nothing_raised do
+            define = interp.newdefine "funtest::mydefine"
+        end
+
+        assert_equal("funtest", klass.namespace,
+            "component namespace was not set in the class")
+
+        assert_equal("funtest", define.namespace,
+            "component namespace was not set in the definition")
+
+        newscope = klass.subscope(scope)
+
+        assert_equal(["funtest"], newscope.namespaces,
+            "Scope did not inherit namespace")
+
+        # Now make sure we can find the define
+        assert(newscope.finddefine("mydefine"),
+            "Could not find definition in my enclosing class")
+    end
+
+    # Make sure that our scope is a subscope of the parentclass's scope.
+    # At the same time, make sure definitions in the parent class can be
+    # found within the subclass (#517).
+    def test_parent_scope_from_parentclass
+        interp = mkinterp
+
+        interp.newclass("base")
+        fun = interp.newdefine("base::fun")
+        interp.newclass("middle", :parent => "base")
+        interp.newclass("sub", :parent => "middle")
+        scope = mkscope :interp => interp
+
+        ret = nil
+        assert_nothing_raised do
+            ret = scope.evalclasses("sub")
+        end
+
+        subscope = scope.class_scope(scope.findclass("sub"))
+        assert(subscope, "could not find sub scope")
+        mscope = scope.class_scope(scope.findclass("middle"))
+        assert(mscope, "could not find middle scope")
+        pscope = scope.class_scope(scope.findclass("base"))
+        assert(pscope, "could not find parent scope")
+
+        assert(pscope == mscope.parent, "parent scope of middle was not set correctly")
+        assert(mscope == subscope.parent, "parent scope of sub was not set correctly")
+
+        result = mscope.finddefine("fun")
+        assert(result, "could not find parent-defined definition from middle")
+        assert(fun == result, "found incorrect parent-defined definition from middle")
+
+        result = subscope.finddefine("fun")
+        assert(result, "could not find parent-defined definition from sub")
+        assert(fun == result, "found incorrect parent-defined definition from sub")
+    end
+end
+
+# $Id: hostclass.rb 2259 2007-03-06 19:03:05Z luke $

data/test/language/ast/selector.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2006-12-22.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppettest/parsertesting'
+
+class TestSelector < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::ParserTesting
+	AST = Puppet::Parser::AST
+    
+    def test_evaluate
+        scope = mkscope
+        upperparam = nameobj("MYPARAM")
+        lowerparam = nameobj("myparam")
+        
+        should = {"MYPARAM" => "upper", "myparam" => "lower"}
+        
+        maker = Proc.new do
+            {
+            :default => AST::ResourceParam.new(:param => AST::Default.new(:value => "default"), :value => FakeAST.new("default")),
+            :lower => AST::ResourceParam.new(:param => FakeAST.new("myparam"), :value => FakeAST.new("lower")),
+            :upper => AST::ResourceParam.new(:param => FakeAST.new("MYPARAM"), :value => FakeAST.new("upper")),
+            }
+            
+        end
+        
+        # Start out case-sensitive
+        Puppet[:casesensitive] = true
+        
+        %w{MYPARAM myparam}.each do |str|
+            param = nameobj(str)
+            params = maker.call()
+            sel = AST::Selector.new(:param => param, :values => params.values)
+            result = nil
+            assert_nothing_raised { result = sel.evaluate(:scope => scope) }
+            assert_equal(should[str], result, "did not case-sensitively match %s" % str)
+        end
+        
+        # then insensitive
+        Puppet[:casesensitive] = false
+        
+        %w{MYPARAM myparam}.each do |str|
+            param = nameobj(str)
+            params = maker.call()
+
+            # Delete the upper value, since we don't want it to match
+            # and it introduces a hash-ordering bug in testing.
+            params.delete(:upper)
+            sel = AST::Selector.new(:param => param, :values => params.values)
+            result = nil
+            assert_nothing_raised { result = sel.evaluate(:scope => scope) }
+            assert_equal("lower", result, "did not case-insensitively match %s" % str)
+        end
+    end
+end
+
+# $Id: selector.rb 2142 2007-02-01 00:58:11Z luke $