puppet 0.16.0 → 0.18.4

data/test/executables/puppetmodule.rb

@@ -44,7 +44,7 @@ class TestPuppetModule < Test::Unit::TestCase
         ENV["CFALLCLASSES"] = "yaytest:all"
 
         assert_nothing_raised {
-            system(cmd + " " + file)
+            %x{#{cmd + " " + file} 2>&1}
         }
         assert($? == 0, "Puppet module exited with code %s" % $?.to_i)
 
@@ -52,4 +52,4 @@ class TestPuppetModule < Test::Unit::TestCase
     end
 end
 
-# $Id: puppetmodule.rb 873 2006-02-07 23:12:33Z luke $
+# $Id: puppetmodule.rb 1256 2006-06-13 15:57:06Z luke $

data/test/language/ast.rb

@@ -53,13 +53,20 @@ class TestAST < Test::Unit::TestCase
         }
 
         scope = nil
+        objects = nil
         assert_nothing_raised("Could not evaluate") {
             scope = Puppet::Parser::Scope.new()
-            objects = top.evaluate(:scope => scope)
+            objects = scope.evaluate(:ast => top)
         }
 
+        assert_instance_of(Puppet::TransBucket, objects)
+
         assert_equal(1, scope.find_all { |child|
-            child.lookupobject(:name => "/parent", :type => "file")
+            if child.is_a? Puppet::Parser::Scope
+                child.lookupobject(:name => "/parent", :type => "file")
+            else
+                nil
+            end
         }.length, "Found incorrect number of '/parent' objects")
 
         assert_equal(classes.sort, scope.classlist.sort)
@@ -127,7 +134,7 @@ class TestAST < Test::Unit::TestCase
         scope = nil
         assert_raise(Puppet::ParseError, "Invalid parent type was allowed") {
             scope = Puppet::Parser::Scope.new()
-            objects = top.evaluate(:scope => scope)
+            objects = scope.evaluate(:ast => top)
         }
     end
 
@@ -240,8 +247,7 @@ class TestAST < Test::Unit::TestCase
                 end
                 assert(Puppet::Type.type(:file)["/#{name}"], "Could not find '#{name}'")
             end
-
-            Puppet::Type.type(:file).clear
+            Puppet::Type.allclear
         end
     end
 
@@ -417,13 +423,16 @@ class TestAST < Test::Unit::TestCase
             objects = scope.evaluate(:names => [name], :facts => {}, :ast => top)
         }
         assert(objects, "Could not retrieve short node definition")
+        assert_instance_of(Puppet::TransBucket, objects)
 
         # And now verify that we got both the top and node objects
         assert_nothing_raised("Could not find top-declared object") {
             assert_equal("/testing", objects[0].name)
         }
 
-        assert_nothing_raised("Could not find node-declared object") {
+        assert_nothing_raised("Could not find node-declared object %s" %
+            "/%s" % name
+        ) {
             assert_equal("/%s" % name, objects[1][0].name)
         }
     end
@@ -454,19 +463,19 @@ class TestAST < Test::Unit::TestCase
 
         # Evaluate the parse tree
         scope = nil
+        objects = nil
         assert_nothing_raised("Could not evaluate node") {
             scope = Puppet::Parser::Scope.new()
-            top.evaluate(:scope => scope)
+            objects = scope.evaluate(:ast => top)
         }
 
         # Verify we get the right classlist back
         assert_equal(classes.sort, scope.classlist.sort)
 
         # Verify we can find the node via a search list
-        objects = nil
-        assert_nothing_raised("Could not retrieve objects") {
-            objects = scope.to_trans
-        }
+        #assert_nothing_raised("Could not retrieve objects") {
+        #    objects = scope.to_trans
+        #}
         assert(objects, "Could not retrieve objects")
 
         assert_nothing_raised("Could not find top-declared object") {
@@ -701,4 +710,184 @@ class TestAST < Test::Unit::TestCase
             "Node's long name got set")
         assert(scope.classlist.include?("node"), "Node's name did not get set")
     end
+
+    # Make sure that deep class parentage works
+    def test_classparentage
+        children = []
+        files = []
+        base = classobj("base")
+        files << "/base"
+
+        children << base
+
+        parent = "base"
+        5.times { |i|
+            name = "child%s" % i
+            files << "/%s" % name
+            children << classobj(name, :parentclass => nameobj(parent))
+
+            parent = name
+        }
+
+        children << functionobj("include", parent)
+
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        objects = nil
+        assert_nothing_raised("Could not evaluate") {
+            scope = Puppet::Parser::Scope.new()
+            objects = scope.evaluate(:ast => top)
+        }
+
+        objects = objects.flatten
+
+        files.each do |file|
+            assert(objects.find { |o| o.name == file },
+                "Could not find file %s" % file)
+        end
+    end
+
+    # Make sure we catch names that are specified like parameters.
+    def test_name_or_param
+        obj = nil
+        assert_nothing_raised {
+            obj = AST::ObjectDef.new(
+                :type => nameobj("file"),
+                :params => astarray(AST::ObjectParam.new(
+                    :param => stringobj("name"),
+                    :value => stringobj("yayness")
+                ))
+            )
+        }
+
+        scope = Puppet::Parser::Scope.new
+
+        trans = nil
+        assert_nothing_raised {
+            trans = scope.evaluate(:ast => obj, :facts => {})
+        }
+
+        transobj = trans.shift
+        assert(transobj.name, "Name did not convert from param to name")
+    end
+
+    if defined? ActiveRecord
+    # Verify that our collection stuff works.
+    def test_collection
+        collectable = []
+        non = []
+        # First put some objects into the database.
+        bucket = mk_transtree do |object, depth, width|
+            # and mark some of them collectable
+            if width % 2 == 1
+                object.collectable = true
+                collectable << object
+            else
+                non << object
+            end
+        end
+
+        # Now collect our facts
+        facts = {}
+        Facter.each do |fact, value| facts[fact] = value end
+
+        assert_nothing_raised {
+            Puppet::Rails.init
+        }
+
+        # Now try storing our crap
+        assert_nothing_raised {
+            host = Puppet::Rails::Host.store(
+                :objects => bucket,
+                :facts => facts,
+                :host => facts["hostname"]
+            )
+        }
+
+        # Now create an ast tree that collects that.  They should all be files.
+        coll = nil
+        assert_nothing_raised {
+            coll = AST::Collection.new(
+                :type => nameobj("file")
+            )
+        }
+
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => [coll]
+            )
+        }
+
+        objects = nil
+        assert_nothing_raised("Could not evaluate") {
+            scope = Puppet::Parser::Scope.new()
+            objects = scope.evaluate(:ast => top).flatten
+        }
+
+        assert(objects.length > 0, "Did not receive any collected objects")
+    end
+    else
+        $stderr.puts "No ActiveRecord -- skipping collection tests"
+    end
+
+    # To fix #140.  Currently non-functional.
+    def disabled_test_classreuse
+        children = []
+
+        # Create the parent class, with a definition in it.
+        children << classobj("parent", :code => AST::ASTArray.new(
+            :file => __FILE__,
+            :line => __LINE__,
+            :children => [
+                compobj("foo", :args => AST::ASTArray.new(
+                        :children => [nameobj("arg")]
+                    ),
+                    :code => AST::ASTArray.new(
+                        :file => __FILE__,
+                        :line => __LINE__,
+                        :children => [fileobj("/$arg")]
+                    )
+                ),
+                objectdef("foo", "ptest", {"arg" => "parentfoo"})
+            ]
+        ))
+
+        # Create child class, also trying to use that definition
+        children << classobj("child1", :parentclass => nameobj("parent"),
+            :code => AST::ASTArray.new(
+                :file => __FILE__,
+                :line => __LINE__,
+                :children => [
+                    objectdef("foo", "ctest", {"arg" => "childfoo"})
+                ]
+            )
+        )
+
+        # Call the parent first
+        children << functionobj("include", "parent")
+
+        # Then call the child, and make sure it can look up the definition
+        children << functionobj("include", "child1")
+
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        objects = nil
+        assert_nothing_raised("Could not evaluate") {
+            scope = Puppet::Parser::Scope.new()
+            objects = scope.evaluate(:ast => top)
+        }
+    end
 end
+
+# $Id: ast.rb 1256 2006-06-13 15:57:06Z luke $

data/test/language/functions.rb

@@ -0,0 +1,245 @@
+#!/usr/bin/ruby
+
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/parser/interpreter'
+require 'puppet/parser/parser'
+require 'puppet/client'
+require 'test/unit'
+require 'puppettest'
+
+class TestLangFunctions < Test::Unit::TestCase
+	include ParserTesting
+    def test_functions
+        assert_raise(Puppet::ParseError) do
+            Puppet::Parser::AST::Function.new(
+                :name => "fakefunction",
+                :arguments => AST::ASTArray.new(
+                    :children => [nameobj("avalue")]
+                )
+            )
+        end
+
+        assert_nothing_raised do
+            Puppet::Parser::Functions.newfunction(:fakefunction, :rvalue) do |input|
+                return "output %s" % input[0]
+            end
+        end
+
+        func = nil
+        assert_nothing_raised do
+            func = Puppet::Parser::AST::Function.new(
+                :name => "fakefunction",
+                :ftype => :rvalue,
+                :arguments => AST::ASTArray.new(
+                    :children => [nameobj("avalue")]
+                )
+            )
+        end
+
+        scope = Puppet::Parser::Scope.new()
+        val = nil
+        assert_nothing_raised do
+            val = func.evaluate(:scope => scope)
+        end
+
+        assert_equal("output avalue", val)
+    end
+
+    def test_taggedfunction
+        scope = Puppet::Parser::Scope.new()
+
+        tag = "yayness"
+        scope.setclass(tag.object_id, tag)
+
+        {"yayness" => true, "booness" => false}.each do |tag, retval|
+            func = taggedobj(tag, :rvalue)
+
+            val = nil
+            assert_nothing_raised do
+                val = func.evaluate(:scope => scope)
+            end
+
+            assert_equal(retval, val, "'tagged' returned %s for %s" % [val, tag])
+        end
+    end
+
+    def test_failfunction
+        func = nil
+        assert_nothing_raised do
+            func = Puppet::Parser::AST::Function.new(
+                :name => "fail",
+                :ftype => :statement,
+                :arguments => AST::ASTArray.new(
+                    :children => [stringobj("this is a failure"),
+                        stringobj("and another")]
+                )
+            )
+        end
+
+        scope = Puppet::Parser::Scope.new()
+        val = nil
+        assert_raise(Puppet::ParseError) do
+            val = func.evaluate(:scope => scope)
+        end
+    end
+
+    def test_multipletemplates
+        Dir.mkdir(Puppet[:templatedir])
+        onep = File.join(Puppet[:templatedir], "one")
+        twop = File.join(Puppet[:templatedir], "two")
+
+        File.open(onep, "w") do |f|
+            f.puts "template <%= one %>"
+        end
+
+        File.open(twop, "w") do |f|
+            f.puts "template <%= two %>"
+        end
+        func = nil
+        assert_nothing_raised do
+            func = Puppet::Parser::AST::Function.new(
+                :name => "template",
+                :ftype => :rvalue,
+                :arguments => AST::ASTArray.new(
+                    :children => [stringobj("one"),
+                        stringobj("two")]
+                )
+            )
+        end
+        ast = varobj("output", func)
+
+        scope = Puppet::Parser::Scope.new()
+        assert_raise(Puppet::ParseError) do
+            ast.evaluate(:scope => scope)
+        end
+
+        scope.setvar("one", "One")
+        assert_raise(Puppet::ParseError) do
+            ast.evaluate(:scope => scope)
+        end
+        scope.setvar("two", "Two")
+        assert_nothing_raised do
+            ast.evaluate(:scope => scope)
+        end
+
+        assert_equal("template One\ntemplate Two\n", scope.lookupvar("output"),
+            "Templates were not handled correctly")
+    end
+
+    # Now make sure we can fully qualify files, and specify just one
+    def test_singletemplates
+        template = tempfile()
+
+        File.open(template, "w") do |f|
+            f.puts "template <%= yayness %>"
+        end
+
+        func = nil
+        assert_nothing_raised do
+            func = Puppet::Parser::AST::Function.new(
+                :name => "template",
+                :ftype => :rvalue,
+                :arguments => AST::ASTArray.new(
+                    :children => [stringobj(template)]
+                )
+            )
+        end
+        ast = varobj("output", func)
+
+        scope = Puppet::Parser::Scope.new()
+        assert_raise(Puppet::ParseError) do
+            ast.evaluate(:scope => scope)
+        end
+
+        scope.setvar("yayness", "this is yayness")
+
+        assert_nothing_raised do
+            ast.evaluate(:scope => scope)
+        end
+
+        assert_equal("template this is yayness\n", scope.lookupvar("output"),
+            "Templates were not handled correctly")
+
+    end
+
+    def test_tempatefunction_cannot_see_scopes
+        template = tempfile()
+
+        File.open(template, "w") do |f|
+            f.puts "<%= lookupvar('myvar') %>"
+        end
+
+        func = nil
+        assert_nothing_raised do
+            func = Puppet::Parser::AST::Function.new(
+                :name => "template",
+                :ftype => :rvalue,
+                :arguments => AST::ASTArray.new(
+                    :children => [stringobj(template)]
+                )
+            )
+        end
+        ast = varobj("output", func)
+
+        scope = Puppet::Parser::Scope.new()
+        scope.setvar("myvar", "this is yayness")
+        assert_raise(Puppet::ParseError) do
+            ast.evaluate(:scope => scope)
+        end
+    end
+
+    def test_template_reparses
+        template = tempfile()
+
+        File.open(template, "w") do |f|
+            f.puts "original text"
+        end
+
+        manifest = tempfile()
+        file = tempfile()
+        File.open(manifest, "w") do |f|
+            f.puts %{file { "#{file}": content => template("#{template}") }}
+        end
+
+        interpreter = Puppet::Parser::Interpreter.new(
+            :Manifest => manifest,
+            :UseNodes => false
+        )
+
+        parsedate = interpreter.parsedate()
+
+        objects = nil
+        assert_nothing_raised {
+            objects = interpreter.run("myhost", {})
+        }
+
+        fileobj = objects[0]
+
+        assert_equal("original text\n", fileobj["content"],
+            "Template did not work")
+
+        Puppet[:filetimeout] = 0
+        # Have to sleep because one second is the fs's time granularity.
+        sleep(1)
+
+        # Now modify the template
+        File.open(template, "w") do |f|
+            f.puts "new text"
+        end
+
+        assert_nothing_raised {
+            objects = interpreter.run("myhost", {})
+        }
+        newdate = interpreter.parsedate()
+
+        assert(parsedate != newdate, "Parse date did not change")
+    end
+end
+
+# $Id: functions.rb 1421 2006-07-21 23:12:51Z luke $