puppet 0.18.4 → 0.22.4

data/test/language/ast/variable.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2007-0419.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppettest/parsertesting'
+
+class TestVariable < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::ParserTesting
+	AST = Puppet::Parser::AST
+    
+    def setup
+        super
+        @interp = mkinterp
+        @scope = mkscope :interp => @interp
+        @name = "myvar"
+        @var = AST::Variable.new(:value => @name)
+    end
+
+    def test_evaluate
+        assert_equal("", @var.evaluate(:scope => @scope), "did not return empty string on unset var")
+        @scope.setvar(@name, "something")
+        assert_equal("something", @var.evaluate(:scope => @scope), "incorrect variable value")
+    end
+end
+
+# $Id: variable.rb 2393 2007-04-19 18:34:03Z luke $

data/test/language/collector.rb

@@ -0,0 +1,369 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet/rails'
+require 'puppettest'
+require 'puppettest/parsertesting'
+require 'puppettest/resourcetesting'
+require 'puppettest/railstesting'
+
+class TestCollector < Test::Unit::TestCase
+	include PuppetTest
+    include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
+    include PuppetTest::RailsTesting
+    Parser = Puppet::Parser
+    AST = Parser::AST
+
+    def setup
+        super
+        Puppet[:trace] = false
+        @interp, @scope, @source = mkclassframing
+    end
+
+    # Test just collecting a specific resource.  This is used by the 'realize'
+    # function, and it's much faster than iterating over all of the resources.
+    def test_collect_resource
+        # Make a collector
+        coll = nil
+        assert_nothing_raised do
+            coll = Puppet::Parser::Collector.new(@scope, "file", nil, nil, :virtual)
+        end
+
+        # Now set the resource in the collector
+        assert_nothing_raised do 
+            coll.resources = ["File[/tmp/virtual1]", "File[/tmp/virtual3]"]
+        end
+        @scope.newcollection(coll)
+
+        # Evaluate the collector and make sure it doesn't fail with no resources
+        # found yet
+        assert_nothing_raised("Resource collection with no results failed") do
+            assert_equal(false, coll.evaluate)
+        end
+
+        # Make a couple of virtual resources
+        one = mkresource(:type => "file", :title => "/tmp/virtual1",
+            :virtual => true, :params => {:owner => "root"})
+        two = mkresource(:type => "file", :title => "/tmp/virtual2",
+            :virtual => true, :params => {:owner => "root"})
+        @scope.setresource one
+        @scope.setresource two
+
+        # Now run the collector again and make sure it finds our resource
+        assert_nothing_raised do
+            assert_equal([one], coll.evaluate, "did not find resource")
+        end
+
+        # And make sure the resource is no longer virtual
+        assert(! one.virtual?,
+            "Resource is still virtual")
+
+        # But the other still is
+        assert(two.virtual?,
+            "Resource got realized")
+
+        # Make sure that the collection is still there
+        assert(@scope.collections.include?(coll), "collection was deleted too soon")
+
+        # Now add our third resource
+        three = mkresource(:type => "file", :title => "/tmp/virtual3",
+            :virtual => true, :params => {:owner => "root"})
+        @scope.setresource three
+
+        # Run the collection
+        assert_nothing_raised do
+            assert_equal([three], coll.evaluate, "did not find resource")
+        end
+        assert(! three.virtual?, "three is still virtual")
+
+        # And make sure that the collection got deleted from the scope's list
+        assert(@scope.collections.empty?, "collection was not deleted")
+    end
+
+    def test_virtual
+        # Make a virtual resource
+        virtual = mkresource(:type => "file", :title => "/tmp/virtual",
+            :virtual => true, :params => {:owner => "root"})
+        @scope.setresource virtual
+
+        # And a non-virtual
+        real = mkresource(:type => "file", :title => "/tmp/real",
+            :params => {:owner => "root"})
+        @scope.setresource real
+
+        # Now make a collector
+        coll = nil
+
+        # Make a fake query
+        code = proc do |res|
+            true
+        end
+        assert_nothing_raised do
+            coll = Puppet::Parser::Collector.new(@scope, "file", nil, code, :virtual)
+        end
+
+        # Set it in our scope
+        @scope.newcollection(coll)
+
+        # Make sure it's in the collections
+        assert(@scope.collections.include?(coll), "collection was not added")
+
+        # And try to collect the virtual resources.
+        ret = nil
+        assert_nothing_raised do
+            ret = coll.collect_virtual
+        end
+
+        assert_equal([virtual], ret)
+
+        # Now make sure evaluate does the right thing.
+        assert_nothing_raised do
+            ret = coll.evaluate
+        end
+
+        # And make sure our virtual object is no longer virtual
+        assert(! virtual.virtual?, "Virtual object did not get realized")
+
+        # Now make a new collector of a different type and make sure it
+        # finds nothing.
+        assert_nothing_raised do
+            coll = Puppet::Parser::Collector.new(@scope, "exec", nil, nil, :virtual)
+        end
+
+        # Remark this as virtual
+        virtual.virtual = true
+
+        assert_nothing_raised do
+            ret = coll.evaluate
+        end
+
+        assert_equal(false, ret)
+    end
+
+    if Puppet.features.rails?
+    def test_collect_exported
+        railsinit
+
+        # Set a hostname
+        @scope.host = Facter.value(:hostname)
+
+        # make an exported resource
+        exported = mkresource(:type => "file", :title => "/tmp/exported",
+            :exported => true, :params => {:owner => "root"})
+        @scope.setresource exported
+
+        assert(exported.exported?, "Object was not marked exported")
+        assert(exported.virtual?, "Object was not marked virtual")
+
+        # And a non-exported
+        real = mkresource(:type => "file", :title => "/tmp/real",
+            :params => {:owner => "root"})
+        @scope.setresource real
+
+        # Now make a collector
+        coll = nil
+        assert_nothing_raised do
+            coll = Puppet::Parser::Collector.new(@scope, "file", nil, nil, :exported)
+        end
+
+        # Set it in our scope
+        @scope.newcollection(coll)
+
+        # Make sure it's in the collections
+        assert_equal([coll], @scope.collections)
+
+        # And try to collect the virtual resources.
+        ret = nil
+        assert_nothing_raised do
+            ret = coll.collect_exported
+        end
+
+        assert_equal([exported], ret)
+
+        # Now make sure evaluate does the right thing.
+        assert_nothing_raised do
+            ret = coll.evaluate
+        end
+
+        # Make sure that the collection does not find the resource on the
+        # next run.
+        ret = nil
+        assert_nothing_raised do
+            ret = coll.collect_exported
+        end
+
+        assert(ret.empty?, "Exported resource was collected on the second run")
+
+
+        # And make sure our exported object is no longer exported
+        assert(! exported.virtual?, "Virtual object did not get realized")
+
+        # But it should still be marked exported.
+        assert(exported.exported?, "Resource got un-exported")
+
+        # Now make a new collector of a different type and make sure it
+        # finds nothing.
+        assert_nothing_raised do
+            coll = Puppet::Parser::Collector.new(@scope, "exec", nil, nil, :exported)
+        end
+
+        # Remark this as virtual
+        exported.virtual = true
+
+        assert_nothing_raised do
+            ret = coll.evaluate
+        end
+
+        assert(! ret, "got resources back")
+
+        # Now create a whole new scope and make sure we can actually retrieve
+        # the resource from the database, not just from the scope.
+        # First create a host object and store our resource in it.
+
+        # Now collect our facts
+        facts = {}
+        Facter.each do |fact, value| facts[fact] = value end 
+
+        # Now try storing our crap
+        # Remark this as exported
+        exported.exported = true
+        host = Puppet::Rails::Host.store(
+            :resources => [exported],
+            :facts => facts,
+            :name => facts["hostname"]
+        )
+        assert(host, "did not get rails host")
+        host.save
+
+        # And make sure it's in there
+        newres = host.resources.find_by_restype_and_title_and_exported("file", "/tmp/exported", true)
+        assert(newres, "Did not find resource in db")
+        interp, scope, source = mkclassframing
+        scope.host = "two"
+
+        # Now make a collector
+        coll = nil
+        assert_nothing_raised do
+            coll = Puppet::Parser::Collector.new(scope, "file", nil, nil, :exported)
+        end
+
+        # Set it in our scope
+        scope.newcollection(coll)
+
+        # Make sure it's in the collections
+        assert_equal([coll], scope.collections)
+
+        # And try to collect the virtual resources.
+        ret = nil
+        assert_nothing_raised do
+            ret = coll.collect_exported
+        end
+
+        assert_equal(["/tmp/exported"], ret.collect { |f| f.title })
+
+        # Make sure we can evaluate the same collection multiple times and
+        # that later collections do nothing
+        assert_nothing_raised("Collection found same resource twice") do
+            ret = coll.evaluate
+        end
+    end
+
+    def test_collection_conflicts
+        railsinit
+
+        # First make a railshost we can conflict with
+        host = Puppet::Rails::Host.new(:name => "myhost")
+
+        host.resources.build(:title => "/tmp/conflicttest", :restype => "file",
+            :exported => true)
+
+        host.save
+
+        # Now make a normal resource
+        normal = mkresource(:type => "file", :title => "/tmp/conflicttest",
+            :params => {:owner => "root"})
+        @scope.setresource normal
+        @scope.host = "otherhost"
+
+        # Now make a collector
+        coll = nil
+        assert_nothing_raised do
+            coll = Puppet::Parser::Collector.new(@scope, "file", nil, nil, :exported)
+        end
+
+        # And try to collect the virtual resources.
+        assert_raise(Puppet::ParseError) do
+            ret = coll.collect_exported
+        end
+    end
+
+    # Make sure we do not collect resources from the host we're on
+    def test_no_resources_from_me
+        railsinit
+
+        # Make our configuration
+        host = Puppet::Rails::Host.new(:name => "myhost")
+
+        host.resources.build(:title => "/tmp/hosttest", :type => "file",
+            :exported => true)
+
+        host.save
+
+        @scope.host = "myhost"
+
+        # Now make a collector
+        coll = nil
+        assert_nothing_raised do
+            coll = Puppet::Parser::Collector.new(@scope, "file", nil, nil, :exported)
+        end
+
+        # And make sure we get nada back
+        ret = nil
+        assert_nothing_raised do
+            ret = coll.collect_exported
+        end
+
+        assert(ret.empty?, "Found exports from our own host")
+    end
+    end
+
+    # Collections that specify resources should be deleted when they succeed,
+    # but others should remain until the very end.
+    def test_normal_collections_remain
+        # Make a collector
+        coll = nil
+        assert_nothing_raised do
+            coll = Puppet::Parser::Collector.new(@scope, "file", nil, nil, :virtual)
+        end
+
+        @scope.newcollection(coll)
+
+        # run the collection and make sure it doesn't get deleted, since it
+        # didn't return anything
+        assert_nothing_raised do
+            assert_equal(false, coll.evaluate,
+                "Evaluate returned incorrect value")
+        end
+
+        assert_equal([coll], @scope.collections, "Collection was deleted")
+
+        # Make a resource
+        one = mkresource(:type => "file", :title => "/tmp/virtual1",
+            :virtual => true, :params => {:owner => "root"})
+        @scope.setresource one
+
+        # Now perform the collection again, and it should still be there
+        assert_nothing_raised do
+            assert_equal([one], coll.evaluate,
+                "Evaluate returned incorrect value")
+        end
+
+        assert_equal([coll], @scope.collections, "Collection was deleted")
+
+        assert_equal(false, one.virtual?, "One was not realized")
+    end
+end
+
+# $Id: collector.rb 2213 2007-02-18 05:58:27Z luke $

data/test/language/functions.rb

@@ -1,20 +1,17 @@
-#!/usr/bin/ruby
+#!/usr/bin/env ruby
 
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppet/parser/interpreter'
 require 'puppet/parser/parser'
-require 'puppet/client'
-require 'test/unit'
+require 'puppet/network/client'
 require 'puppettest'
+require 'puppettest/resourcetesting'
 
 class TestLangFunctions < Test::Unit::TestCase
-	include ParserTesting
+    include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
     def test_functions
         assert_raise(Puppet::ParseError) do
             Puppet::Parser::AST::Function.new(
@@ -26,7 +23,7 @@ class TestLangFunctions < Test::Unit::TestCase
         end
 
         assert_nothing_raised do
-            Puppet::Parser::Functions.newfunction(:fakefunction, :rvalue) do |input|
+            Puppet::Parser::Functions.newfunction(:fakefunction, :type => :rvalue) do |input|
                 return "output %s" % input[0]
             end
         end
@@ -42,7 +39,7 @@ class TestLangFunctions < Test::Unit::TestCase
             )
         end
 
-        scope = Puppet::Parser::Scope.new()
+        scope = mkscope
         val = nil
         assert_nothing_raised do
             val = func.evaluate(:scope => scope)
@@ -52,10 +49,10 @@ class TestLangFunctions < Test::Unit::TestCase
     end
 
     def test_taggedfunction
-        scope = Puppet::Parser::Scope.new()
+        scope = mkscope
 
         tag = "yayness"
-        scope.setclass(tag.object_id, tag)
+        scope.tag(tag)
 
         {"yayness" => true, "booness" => false}.each do |tag, retval|
             func = taggedobj(tag, :rvalue)
@@ -82,7 +79,7 @@ class TestLangFunctions < Test::Unit::TestCase
             )
         end
 
-        scope = Puppet::Parser::Scope.new()
+        scope = mkscope
         val = nil
         assert_raise(Puppet::ParseError) do
             val = func.evaluate(:scope => scope)
@@ -114,7 +111,7 @@ class TestLangFunctions < Test::Unit::TestCase
         end
         ast = varobj("output", func)
 
-        scope = Puppet::Parser::Scope.new()
+        scope = mkscope
         assert_raise(Puppet::ParseError) do
             ast.evaluate(:scope => scope)
         end
@@ -152,7 +149,7 @@ class TestLangFunctions < Test::Unit::TestCase
         end
         ast = varobj("output", func)
 
-        scope = Puppet::Parser::Scope.new()
+        scope = mkscope
         assert_raise(Puppet::ParseError) do
             ast.evaluate(:scope => scope)
         end
@@ -187,7 +184,7 @@ class TestLangFunctions < Test::Unit::TestCase
         end
         ast = varobj("output", func)
 
-        scope = Puppet::Parser::Scope.new()
+        scope = mkscope
         scope.setvar("myvar", "this is yayness")
         assert_raise(Puppet::ParseError) do
             ast.evaluate(:scope => scope)
@@ -240,6 +237,296 @@ class TestLangFunctions < Test::Unit::TestCase
 
         assert(parsedate != newdate, "Parse date did not change")
     end
+
+    def test_template_defined_vars
+        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)
+
+        {
+            "" => "",
+            false => "false",
+        }.each do |string, value|
+            scope = mkscope
+            assert_raise(Puppet::ParseError) do
+                ast.evaluate(:scope => scope)
+            end
+
+            scope.setvar("yayness", string)
+            assert_equal(string, scope.lookupvar("yayness", false))
+
+            assert_nothing_raised("An empty string was not a valid variable value") do
+                ast.evaluate(:scope => scope)
+            end
+
+            assert_equal("template #{value}\n", scope.lookupvar("output"),
+                         "%s did not get evaluated correctly" % string.inspect)
+        end
+    end
+
+    def test_autoloading_functions
+        assert_equal(false, Puppet::Parser::Functions.function(:autofunc),
+            "Got told autofunc already exists")
+
+        dir = tempfile()
+        $: << dir
+        newpath = File.join(dir, "puppet", "parser", "functions")
+        FileUtils.mkdir_p(newpath)
+
+        File.open(File.join(newpath, "autofunc.rb"), "w") { |f|
+            f.puts %{
+                Puppet::Parser::Functions.newfunction(:autofunc, :type => :rvalue) do |vals|
+                    Puppet.wanring vals.inspect
+                end
+            }
+        }
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Puppet::Parser::Functions.function(:autofunc)
+        }
+
+        assert(obj, "Did not autoload function")
+        assert(Puppet::Parser::Scope.method_defined?(:function_autofunc),
+            "Did not set function correctly")
+    end
+
+    def test_realize
+        @interp, @scope, @source = mkclassframing
+    
+        # Make a definition
+        @interp.newdefine("mytype")
+        
+        [%w{file /tmp/virtual}, %w{mytype yay}].each do |type, title|
+            # Make a virtual resource
+            virtual = mkresource(:type => type, :title => title,
+                :virtual => true, :params => {})
+        
+            @scope.setresource virtual
+
+            ref = Puppet::Parser::Resource::Reference.new(
+                :type => type, :title => title,
+                :scope => @scope
+            )
+            # Now call the realize function
+            assert_nothing_raised do
+                @scope.function_realize(ref)
+            end
+
+            # Make sure it created a collection
+            assert_equal(1, @scope.collections.length,
+                "Did not set collection")
+
+            assert_nothing_raised do
+                @scope.collections.each do |coll| coll.evaluate end
+            end
+            @scope.collections.clear
+
+            # Now make sure the virtual resource is no longer virtual
+            assert(! virtual.virtual?, "Did not make virtual resource real")
+        end
+
+        # Make sure we puke on any resource that doesn't exist
+        none = Puppet::Parser::Resource::Reference.new(
+            :type => "file", :title => "/tmp/nosuchfile",
+            :scope => @scope
+        )
+
+        # The function works
+        assert_nothing_raised do
+            @scope.function_realize(none.to_s)
+        end
+
+        # Make sure it created a collection
+        assert_equal(1, @scope.collections.length,
+            "Did not set collection")
+
+        # And the collection has our resource in it
+        assert_equal([none.to_s], @scope.collections[0].resources,
+            "Did not set resources in collection")
+    end
+    
+    def test_defined
+        interp = mkinterp
+        scope = mkscope(:interp => interp)
+        
+        interp.newclass("yayness")
+        interp.newdefine("rahness")
+        
+        assert_nothing_raised do
+            assert(scope.function_defined("yayness"), "yayness class was not considered defined")
+            assert(scope.function_defined("rahness"), "rahness definition was not considered defined")
+            assert(scope.function_defined("service"), "service type was not considered defined")
+            assert(! scope.function_defined("fakness"), "fakeness was considered defined")
+        end
+        
+        # Now make sure any match in a list will work
+        assert(scope.function_defined(["booness", "yayness", "fakeness"]),
+            "A single answer was not sufficient to return true")
+        
+        # and make sure multiple falses are still false
+        assert(! scope.function_defined(%w{no otherno stillno}),
+            "Multiple falses were somehow true")
+        
+        # Now make sure we can test resources
+        scope.setresource mkresource(:type => "file", :title => "/tmp/rahness",
+            :scope => scope, :source => scope.source,
+            :params => {:owner => "root"})
+        
+        yep = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/rahness")
+        nope = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/fooness")
+        
+        assert(scope.function_defined([yep]), "valid resource was not considered defined")
+        assert(! scope.function_defined([nope]), "invalid resource was considered defined")
+    end
+
+    def test_search
+        interp = mkinterp
+        scope = mkscope(:interp => interp)
+        
+        fun = interp.newdefine("fun::test")
+        foo = interp.newdefine("foo::bar")
+
+        search = Puppet::Parser::Functions.function(:search)
+        assert_nothing_raised do
+            scope.function_search(["foo", "fun"])
+        end
+
+        ffun = ffoo = nil
+        assert_nothing_raised do
+            ffun = scope.finddefine("test")
+            ffoo = scope.finddefine('bar')
+        end
+
+        assert(ffun, "Could not find definition in 'fun' namespace")
+        assert(ffoo, "Could not find definition in 'foo' namespace")
+    end
+
+    def test_include
+        interp = mkinterp
+        scope = mkscope(:interp => interp)
+
+        assert_raise(Puppet::ParseError, "did not throw error on missing class") do
+            scope.function_include("nosuchclass")
+        end
+
+        interp.newclass("myclass")
+
+        assert_nothing_raised do
+            scope.function_include "myclass"
+        end
+
+        assert(scope.classlist.include?("myclass"),
+            "class was not evaluated")
+
+        # Now try multiple classes at once
+        classes = %w{one two three}.each { |c| interp.newclass(c) }
+
+        assert_nothing_raised do
+            scope.function_include classes
+        end
+
+        classes.each do |c|
+            assert(scope.classlist.include?(c),
+                "class %s was not evaluated" % c)
+        end
+
+        # Now try a scoped class
+        interp.newclass("os::redhat")
+
+        assert_nothing_raised("Could not include qualified class name") do
+            scope.function_include("os::redhat")
+        end
+    end
+
+    def test_file
+        interp = mkinterp
+        scope = mkscope(:interp => interp)
+
+        file1 = tempfile
+        file2 = tempfile
+        file3 = tempfile
+
+        File.open(file2, "w") { |f| f.puts "yaytest" }
+
+        val = nil
+        assert_nothing_raised("Failed to call file with one arg") do
+            val = scope.function_file([file2])
+        end
+
+        assert_equal("yaytest\n", val, "file() failed")
+
+        assert_nothing_raised("Failed to call file with two args") do
+            val = scope.function_file([file1, file2])
+        end
+
+        assert_equal("yaytest\n", val, "file() failed")
+
+        assert_raise(Puppet::ParseError, "did not fail when files are missing") do
+            val = scope.function_file([file1, file3])
+        end
+    end
+
+    def test_generate
+        command = tempfile
+        sh = %x{which sh}
+        File.open(command, "w") do |f|
+            f.puts %{#!#{sh}
+            if [ -n "$1" ]; then
+                echo "yay-$1"
+            else
+                echo yay
+            fi
+            }
+        end
+        File.chmod(0755, command)
+        assert_equal("yay\n", %x{#{command}}, "command did not work")
+        assert_equal("yay-foo\n", %x{#{command} foo}, "command did not work")
+
+        interp = mkinterp
+        scope = mkscope(:interp => interp)
+
+        val = nil
+        assert_nothing_raised("Could not call generator with no args") do
+            val = scope.function_generate([command])
+        end
+        assert_equal("yay\n", val, "generator returned wrong results")
+
+        assert_nothing_raised("Could not call generator with args") do
+            val = scope.function_generate([command, "foo"])
+        end
+        assert_equal("yay-foo\n", val, "generator returned wrong results")
+
+        assert_raise(Puppet::ParseError, "Did not fail with an unqualified path") do
+            val = scope.function_generate([File.basename(command), "foo"])
+        end
+
+        assert_raise(Puppet::ParseError, "Did not fail when command failed") do
+            val = scope.function_generate([%x{which touch}.chomp, "/this/dir/does/not/exist"])
+        end
+
+        fake = File.join(File.dirname(command), "..")
+        dir = File.dirname(command)
+        dirname = File.basename(dir)
+        bad = File.join(dir, "..", dirname, File.basename(command))
+        assert_raise(Puppet::ParseError, "Did not fail when command failed") do
+            val = scope.function_generate([bad])
+        end
+    end
 end
 
-# $Id: functions.rb 1421 2006-07-21 23:12:51Z luke $
+# $Id: functions.rb 2401 2007-04-20 15:59:09Z luke $