puppet 0.25.5 → 2.6.0

data/test/language/ast/variable.rb

@@ -9,22 +9,21 @@ require 'puppettest'
 require 'puppettest/parsertesting'
 
 class TestVariable < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::ParserTesting
-    AST = Puppet::Parser::AST
+  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 setup
+    super
+    @scope = mkscope
+    @name = "myvar"
+    @var = AST::Variable.new(:value => @name)
+  end
 
-    def test_evaluate
-        assert_equal("", @var.evaluate(@scope), "did not return empty string on unset var")
-        @scope.setvar(@name, "something")
-        assert_equal("something", @var.evaluate(@scope), "incorrect variable value")
-    end
+  def test_evaluate
+    assert_equal(:undef, @var.evaluate(@scope), "did not return :undef on unset var")
+    @scope.setvar(@name, "something")
+    assert_equal("something", @var.evaluate(@scope), "incorrect variable value")
+  end
 end
 

data/test/language/functions.rb

@@ -9,594 +9,535 @@ require 'puppettest'
 require 'puppettest/resourcetesting'
 
 class TestLangFunctions < Test::Unit::TestCase
-    include PuppetTest::ParserTesting
-    include PuppetTest::ResourceTesting
-    def test_functions
-        assert_nothing_raised do
-            Puppet::Parser::AST::Function.new(
-                :name => "fakefunction",
-                :arguments => AST::ASTArray.new(
-                    :children => [nameobj("avalue")]
-                )
-            )
-        end
+  include PuppetTest::ParserTesting
+  include PuppetTest::ResourceTesting
+  def test_functions
+    Puppet::Node::Environment.stubs(:current).returns nil
+    assert_nothing_raised do
 
-        assert_raise(Puppet::ParseError) do
-            func = Puppet::Parser::AST::Function.new(
-                :name => "fakefunction",
-                :arguments => AST::ASTArray.new(
-                    :children => [nameobj("avalue")]
-                )
-            )
-            func.evaluate(mkscope)
-        end
+      Puppet::Parser::AST::Function.new(
 
-        assert_nothing_raised do
-            Puppet::Parser::Functions.newfunction(:fakefunction, :type => :rvalue) do |input|
-                return "output %s" % input[0]
-            end
-        end
+        :name => "fakefunction",
 
-        func = nil
-        assert_nothing_raised do
-            func = Puppet::Parser::AST::Function.new(
-                :name => "fakefunction",
-                :ftype => :rvalue,
-                :arguments => AST::ASTArray.new(
-                    :children => [nameobj("avalue")]
-                )
-            )
-        end
+        :arguments => AST::ASTArray.new(
+          :children => [nameobj("avalue")]
+        )
+      )
+    end
 
-        scope = mkscope
-        val = nil
-        assert_nothing_raised do
-            val = func.evaluate(scope)
-        end
+    assert_raise(Puppet::ParseError) do
 
-        assert_equal("output avalue", val)
+      func = Puppet::Parser::AST::Function.new(
+
+        :name => "fakefunction",
+
+        :arguments => AST::ASTArray.new(
+          :children => [nameobj("avalue")]
+        )
+      )
+      func.evaluate(mkscope)
     end
 
-    def test_taggedfunction
-        scope = mkscope
-        scope.resource.tag("yayness")
+    assert_nothing_raised do
+      Puppet::Parser::Functions.newfunction(:fakefunction, :type => :rvalue) do |input|
+        return "output #{input[0]}"
+      end
+    end
 
-        # Make sure the ast stuff does what it's supposed to
-        {"yayness" => true, "booness" => false}.each do |tag, retval|
-            func = taggedobj(tag, :rvalue)
+    func = nil
+    assert_nothing_raised do
 
-            val = nil
-            assert_nothing_raised do
-                val = func.evaluate(scope)
-            end
+      func = Puppet::Parser::AST::Function.new(
 
-            assert_equal(retval, val, "'tagged' returned %s for %s" % [val, tag])
-        end
+        :name => "fakefunction",
+        :ftype => :rvalue,
 
-        # Now make sure we correctly get tags.
-        scope.resource.tag("resourcetag")
-        assert(scope.function_tagged("resourcetag"), "tagged function did not catch resource tags")
-        scope.compiler.catalog.tag("configtag")
-        assert(scope.function_tagged("configtag"), "tagged function did not catch catalog tags")
-    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
+        :arguments => AST::ASTArray.new(
+          :children => [nameobj("avalue")]
+        )
+      )
+    end
 
-        scope = mkscope
-        val = nil
-        assert_raise(Puppet::ParseError) do
-            val = func.evaluate(scope)
-        end
+    scope = mkscope
+    val = nil
+    assert_nothing_raised do
+      val = func.evaluate(scope)
     end
 
-    def test_multipletemplates
-        Dir.mkdir(Puppet[:templatedir])
-        onep = File.join(Puppet[:templatedir], "one")
-        twop = File.join(Puppet[:templatedir], "two")
+    assert_equal("output avalue", val)
+  end
 
-        File.open(onep, "w") do |f|
-            f.puts "<%- if @one.nil? then raise '@one undefined' end -%>" +
-                "template <%= @one %>"
-        end
+  def test_taggedfunction
+    scope = mkscope
+    scope.resource.tag("yayness")
 
-        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)
+    # Make sure the ast stuff does what it's supposed to
+    {"yayness" => true, "booness" => false}.each do |tag, retval|
+      func = taggedobj(tag, :rvalue)
 
-        scope = mkscope
+      val = nil
+      assert_nothing_raised do
+        val = func.evaluate(scope)
+      end
 
-        # Test that our manual exception throw fails the parse
-        assert_raise(Puppet::ParseError) do
-            ast.evaluate(scope)
-        end
+      assert_equal(retval, val, "'tagged' returned #{val} for #{tag}")
+    end
 
-        # Test that our use of an undefined instance variable does not throw
-        # an exception, but only safely continues.
-        scope.setvar("one", "One")
-        assert_nothing_raised do
-            ast.evaluate(scope)
-        end
+    # Now make sure we correctly get tags.
+    scope.resource.tag("resourcetag")
+    assert(scope.function_tagged("resourcetag"), "tagged function did not catch resource tags")
+    scope.compiler.catalog.tag("configtag")
+    assert(scope.function_tagged("configtag"), "tagged function did not catch catalog tags")
+  end
 
-        # Ensure that we got the output we expected from that evaluation.
-        assert_equal("template One\ntemplate \n", scope.lookupvar("output"),
-                     "Undefined template variables do not raise exceptions")
+  def test_failfunction
+    func = nil
+    assert_nothing_raised do
 
-        # Now, fill in the last variable and make sure the whole thing
-        # evaluates correctly.
-        scope.setvar("two", "Two")
-        scope.unsetvar("output")
-        assert_nothing_raised do
-            ast.evaluate(scope)
-        end
+      func = Puppet::Parser::AST::Function.new(
+
+        :name => "fail",
+        :ftype => :statement,
+
+        :arguments => AST::ASTArray.new(
+          :children => [stringobj("this is a failure"), stringobj("and another")]
+        )
+      )
+    end
 
-        assert_equal("template One\ntemplate Two\n", scope.lookupvar("output"),
-            "Templates were not handled correctly")
+    scope = mkscope
+    val = nil
+    assert_raise(Puppet::ParseError) do
+      val = func.evaluate(scope)
     end
+  end
 
-    # Now make sure we can fully qualify files, and specify just one
-    def test_singletemplates
-        template = tempfile()
+  def test_multipletemplates
+    Dir.mkdir(Puppet[:templatedir])
+    onep = File.join(Puppet[:templatedir], "one")
+    twop = File.join(Puppet[:templatedir], "two")
 
-        File.open(template, "w") do |f|
-            f.puts "template <%= @yay.nil?() ? raise('yay undefined') : @yay %>"
-        end
+    File.open(onep, "w") do |f|
+      f.puts "<%- if @one.nil? then raise '@one undefined' end -%>template <%= @one %>"
+    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)
+    File.open(twop, "w") do |f|
+      f.puts "template <%= @two %>"
+    end
+    func = nil
+    assert_nothing_raised do
 
-        scope = mkscope
-        assert_raise(Puppet::ParseError) do
-            ast.evaluate(scope)
-        end
+      func = Puppet::Parser::AST::Function.new(
 
-        scope.setvar("yay", "this is yay")
+        :name => "template",
+        :ftype => :rvalue,
 
-        assert_nothing_raised do
-            ast.evaluate(scope)
-        end
+        :arguments => AST::ASTArray.new(
+          :children => [stringobj("one"), stringobj("two")]
+        )
+      )
+    end
+    ast = varobj("output", func)
 
-        assert_equal("template this is yay\n", scope.lookupvar("output"),
-            "Templates were not handled correctly")
+    scope = mkscope
 
+    # Test that our manual exception throw fails the parse
+    assert_raise(Puppet::ParseError) do
+      ast.evaluate(scope)
     end
 
-    # Make sure that legacy template variable access works as expected.
-    def test_legacyvariables
-        template = tempfile()
+    # Test that our use of an undefined instance variable does not throw
+    # an exception, but only safely continues.
+    scope.setvar("one", "One")
+    assert_nothing_raised do
+      ast.evaluate(scope)
+    end
 
-        File.open(template, "w") do |f|
-            f.puts "template <%= deprecated %>"
-        end
+    # Ensure that we got the output we expected from that evaluation.
+    assert_equal("template One\ntemplate \n", scope.lookupvar("output"), "Undefined template variables do not raise exceptions")
 
-        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)
+    # Now, fill in the last variable and make sure the whole thing
+    # evaluates correctly.
+    scope.setvar("two", "Two")
+    scope.unsetvar("output")
+    assert_nothing_raised do
+      ast.evaluate(scope)
+    end
 
-        # Verify that we get an exception using old-style accessors.
-        scope = mkscope
-        assert_raise(Puppet::ParseError) do
-            ast.evaluate(scope)
-        end
 
-        # Verify that we evaluate and return their value correctly.
-        scope.setvar("deprecated", "deprecated value")
-        assert_nothing_raised do
-            ast.evaluate(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
 
-        assert_equal("template deprecated value\n", scope.lookupvar("output"),
-                     "Deprecated template variables were not handled correctly")
+    File.open(template, "w") do |f|
+      f.puts "template <%= @yay.nil?() ? raise('yay undefined') : @yay %>"
     end
 
-    # Make sure that problems with kernel method visibility still exist.
-    def test_kernel_module_shadows_deprecated_var_lookup
-        template = tempfile()
-        File.open(template, "w").puts("<%= binding %>")
+    func = nil
+    assert_nothing_raised do
 
-        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)
+      func = Puppet::Parser::AST::Function.new(
 
-        # Verify that Kernel methods still shadow deprecated variable lookups.
-        scope = mkscope
-        assert_nothing_raised("No exception for Kernel shadowed variable names") do
-            ast.evaluate(scope)
-        end
+        :name => "template",
+        :ftype => :rvalue,
+
+        :arguments => AST::ASTArray.new(
+          :children => [stringobj(template)]
+        )
+      )
     end
+    ast = varobj("output", func)
 
-    def test_tempatefunction_cannot_see_scopes
-        template = tempfile()
+    scope = mkscope
+    assert_raise(Puppet::ParseError) do
+      ast.evaluate(scope)
+    end
 
-        File.open(template, "w") do |f|
-            f.puts "<%= lookupvar('myvar') %>"
-        end
+    scope.setvar("yay", "this is yay")
 
-        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)
+    assert_nothing_raised do
+      ast.evaluate(scope)
+    end
 
-        scope = mkscope
-        scope.setvar("myvar", "this is yayness")
-        assert_raise(Puppet::ParseError) do
-            ast.evaluate(scope)
-        end
+
+      assert_equal(
+        "template this is yay\n", scope.lookupvar("output"),
+
+      "Templates were not handled correctly")
+
+  end
+
+  # Make sure that legacy template variable access works as expected.
+  def test_legacyvariables
+    template = tempfile
+
+    File.open(template, "w") do |f|
+      f.puts "template <%= deprecated %>"
     end
 
-    def test_template_reparses
-        template = tempfile()
+    func = nil
+    assert_nothing_raised do
 
-        File.open(template, "w") do |f|
-            f.puts "original text"
-        end
+      func = Puppet::Parser::AST::Function.new(
 
-        file = tempfile()
+        :name => "template",
+        :ftype => :rvalue,
 
-        Puppet[:code] = %{file { "#{file}": content => template("#{template}") }}
-        Puppet[:environment] = "yay"
-        interp = Puppet::Parser::Interpreter.new
-        node = mknode
-        node.stubs(:environment).returns("yay")
+        :arguments => AST::ASTArray.new(
+          :children => [stringobj(template)]
+        )
+      )
+    end
+    ast = varobj("output", func)
+
+    # Verify that we get an exception using old-style accessors.
+    scope = mkscope
+    assert_raise(Puppet::ParseError) do
+      ast.evaluate(scope)
+    end
 
-        Puppet[:environment] = "yay"
+    # Verify that we evaluate and return their value correctly.
+    scope.setvar("deprecated", "deprecated value")
+    assert_nothing_raised do
+      ast.evaluate(scope)
+    end
 
-        catalog = nil
-        assert_nothing_raised {
-            catalog = interp.compile(node)
-        }
 
-        version = catalog.version
+      assert_equal(
+        "template deprecated value\n", scope.lookupvar("output"),
 
-        fileobj = catalog.vertices.find { |r| r.title == file }
-        assert(fileobj, "File was not in catalog")
+          "Deprecated template variables were not handled correctly")
+  end
 
-        assert_equal("original text\n", fileobj["content"],
-            "Template did not work")
+  # Make sure that problems with kernel method visibility still exist.
+  def test_kernel_module_shadows_deprecated_var_lookup
+    template = tempfile
+    File.open(template, "w").puts("<%= binding %>")
 
-        Puppet[:filetimeout] = -5
-        # Have to sleep because one second is the fs's time granularity.
-        sleep(1)
+    func = nil
+    assert_nothing_raised do
 
-        # Now modify the template
-        File.open(template, "w") do |f|
-            f.puts "new text"
-        end
+      func = Puppet::Parser::AST::Function.new(
 
-        newversion = interp.compile(node).version
+        :name => "template",
+        :ftype => :rvalue,
 
-        assert(version != newversion, "Parse date did not change")
+        :arguments => AST::ASTArray.new(
+          :children => [stringobj(template)]
+        )
+      )
     end
+    ast = varobj("output", func)
 
-    def test_template_defined_vars
-        template = tempfile()
+    # Verify that Kernel methods still shadow deprecated variable lookups.
+    scope = mkscope
+    assert_nothing_raised("No exception for Kernel shadowed variable names") do
+      ast.evaluate(scope)
+    end
+  end
 
-        File.open(template, "w") do |f|
-            f.puts "template <%= @yayness %>"
-        end
+  def test_tempatefunction_cannot_see_scopes
+    template = tempfile
 
-        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
-            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)
-            end
-
-            assert_equal("template #{value}\n", scope.lookupvar("output"),
-                         "%s did not get evaluated correctly" % string.inspect)
-        end
+    File.open(template, "w") do |f|
+      f.puts "<%= lookupvar('myvar') %>"
     end
 
-    def test_autoloading_functions
-        #assert_equal(false, Puppet::Parser::Functions.function(:autofunc),
-        #    "Got told autofunc already exists")
+    func = nil
+    assert_nothing_raised do
 
-        dir = tempfile()
-        $: << dir
-        newpath = File.join(dir, "puppet", "parser", "functions")
-        FileUtils.mkdir_p(newpath)
+      func = Puppet::Parser::AST::Function.new(
 
-        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
-            }
-        }
+        :name => "template",
+        :ftype => :rvalue,
 
-        obj = nil
-        assert_nothing_raised {
-            obj = Puppet::Parser::Functions.function(:autofunc)
-        }
+        :arguments => AST::ASTArray.new(
+          :children => [stringobj(template)]
+        )
+      )
+    end
+    ast = varobj("output", func)
 
-        assert(obj, "Did not autoload function")
-        assert(Puppet::Parser::Scope.method_defined?(:function_autofunc),
-            "Did not set function correctly")
+    scope = mkscope
+    scope.setvar("myvar", "this is yayness")
+    assert_raise(Puppet::ParseError) do
+      ast.evaluate(scope)
     end
+  end
 
-    def test_realize
-        scope = mkscope
-        parser = scope.compiler.parser
+  def test_template_reparses
+    template = tempfile
 
-        realize = Puppet::Parser::Functions.function(:realize)
+    File.open(template, "w") do |f|
+      f.puts "original text"
+    end
 
-        # Make a definition
-        parser.newdefine("mytype")
+    file = tempfile
 
-        [%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 => scope)
+    Puppet[:code] = %{file { "#{file}": content => template("#{template}") }}
+    Puppet[:environment] = "yay"
+    node = mknode
+    node.stubs(:environment).returns Puppet::Node::Environment.new
 
-            scope.compiler.add_resource(scope, virtual)
+    Puppet[:environment] = "yay"
 
-            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
+    catalog = Puppet::Parser::Compiler.new(node).compile
 
-            # Make sure it created a collection
-            assert_equal(1, scope.compiler.collections.length,
-                "Did not set collection")
+    version = catalog.version
 
-            assert_nothing_raised do
-                scope.compiler.collections.each do |coll| coll.evaluate end
-            end
-            scope.compiler.collections.clear
+    fileobj = catalog.vertices.find { |r| r.title == file }
+    assert(fileobj, "File was not in catalog")
 
-            # 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
-        )
+      assert_equal(
+        "original text\n", fileobj["content"],
 
-        # The function works
-        assert_nothing_raised do
-            scope.function_realize(none.to_s)
-        end
+      "Template did not work")
 
-        # Make sure it created a collection
-        assert_equal(1, scope.compiler.collections.length,
-            "Did not set collection")
+    Puppet[:filetimeout] = -5
+    # Have to sleep because one second is the fs's time granularity.
+    sleep(1)
 
-        # And the collection has our resource in it
-        assert_equal([none.to_s], scope.compiler.collections[0].resources,
-            "Did not set resources in collection")
+    # Now modify the template
+    File.open(template, "w") do |f|
+      f.puts "new text"
     end
 
-    def test_defined
-        scope = mkscope
-        parser = scope.compiler.parser
+    newversion = Puppet::Parser::Compiler.new(node).compile.version
 
-        defined = Puppet::Parser::Functions.function(:defined)
+    assert(version != newversion, "Parse date did not change")
+  end
 
-        parser.newclass("yayness")
-        parser.newdefine("rahness")
+  def test_template_defined_vars
+    template = tempfile
 
-        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")
+    File.open(template, "w") do |f|
+      f.puts "template <%= @yayness %>"
+    end
 
-        # and make sure multiple falses are still false
-        assert(! scope.function_defined(%w{no otherno stillno}),
-            "Multiple falses were somehow true")
+    func = nil
+    assert_nothing_raised do
 
-        # Now make sure we can test resources
-        scope.compiler.add_resource(scope, mkresource(:type => "file", :title => "/tmp/rahness",
-            :scope => scope, :source => scope.source,
-            :params => {:owner => "root"}))
+      func = Puppet::Parser::AST::Function.new(
 
-        yep = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/rahness")
-        nope = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/fooness")
+        :name => "template",
+        :ftype => :rvalue,
 
-        assert(scope.function_defined([yep]), "valid resource was not considered defined")
-        assert(! scope.function_defined([nope]), "invalid resource was considered defined")
+        :arguments => AST::ASTArray.new(
+          :children => [stringobj(template)]
+        )
+      )
     end
+    ast = varobj("output", func)
 
-    def test_search
-        parser = mkparser
-        scope = mkscope(:parser => parser)
+    {
+      "" => "",
+      false => "false",
+    }.each do |string, value|
+      scope = mkscope
+      scope.setvar("yayness", string)
+      assert_equal(string, scope.lookupvar("yayness", false))
 
-        fun = parser.newdefine("yay::ness")
-        foo = parser.newdefine("foo::bar")
+      assert_nothing_raised("An empty string was not a valid variable value") do
+        ast.evaluate(scope)
+      end
 
-        search = Puppet::Parser::Functions.function(:search)
-        assert_nothing_raised do
-            scope.function_search(["foo", "yay"])
-        end
 
-        ffun = ffoo = nil
-        assert_nothing_raised("Search path change did not work") do
-            ffun = scope.find_definition("ness")
-            ffoo = scope.find_definition('bar')
-        end
+        assert_equal(
+          "template #{value}\n", scope.lookupvar("output"),
 
-        assert(ffun, "Could not find definition in 'fun' namespace")
-        assert(ffoo, "Could not find definition in 'foo' namespace")
+            "#{string.inspect} did not get evaluated correctly")
+    end
+  end
+
+  def test_autoloading_functions
+    #assert_equal(false, Puppet::Parser::Functions.function(:autofunc),
+    #    "Got told autofunc already exists")
+
+    dir = tempfile
+    $LOAD_PATH << 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
+      }
+    }
+    Puppet::Node::Environment.stubs(:current).returns nil
+    obj = nil
+    assert_nothing_raised {
+      obj = Puppet::Parser::Functions.function(:autofunc)
+    }
+
+    assert(obj, "Did not autoload function")
+    assert(Puppet::Parser::Functions.environment_module.method_defined?(:function_autofunc), "Did not set function correctly")
+  end
+
+  def test_search
+    scope = mkscope
+
+    fun = scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yay::ness")
+    foo = scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "foo::bar")
+
+    search = Puppet::Parser::Functions.function(:search)
+    scope.function_search(["foo", "yay"])
+
+    ffun = ffoo = nil
+    assert_nothing_raised("Search path change did not work") do
+      ffun = scope.find_definition("ness")
+      ffoo = scope.find_definition('bar')
     end
 
-    def test_include
-        scope = mkscope
-        parser = scope.compiler.parser
+    assert(ffun, "Could not find definition in 'fun' namespace")
+    assert(ffoo, "Could not find definition in 'foo' namespace")
+  end
 
-        include = Puppet::Parser::Functions.function(:include)
+  def test_include
+    scope = mkscope
+    parser = mkparser
 
-        assert_raise(Puppet::ParseError, "did not throw error on missing class") do
-            scope.function_include("nosuchclass")
-        end
+    include = Puppet::Parser::Functions.function(:include)
 
-        parser.newclass("myclass")
+    assert_raise(Puppet::ParseError, "did not throw error on missing class") do
+      scope.function_include("nosuchclass")
+    end
 
-        scope.compiler.expects(:evaluate_classes).with(%w{myclass otherclass}, scope, false).returns(%w{myclass otherclass})
+    parser.newclass("myclass")
 
-        assert_nothing_raised do
-            scope.function_include(["myclass", "otherclass"])
-        end
+    scope.compiler.expects(:evaluate_classes).with(%w{myclass otherclass}, scope, false).returns(%w{myclass otherclass})
+
+    assert_nothing_raised do
+      scope.function_include(["myclass", "otherclass"])
     end
+  end
 
-    def test_file
-        parser = mkparser
-        scope = mkscope(:parser => parser)
+  def test_file
+    parser = mkparser
+    scope = mkscope(:parser => parser)
 
-        file = Puppet::Parser::Functions.function(:file)
+    file = Puppet::Parser::Functions.function(:file)
 
-        file1 = tempfile
-        file2 = tempfile
-        file3 = tempfile
+    file1 = tempfile
+    file2 = tempfile
+    file3 = tempfile
 
-        File.open(file2, "w") { |f| f.puts "yaytest" }
+    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
+    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_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_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_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
+    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")
 
-    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")
-
-        generate = Puppet::Parser::Functions.function(:generate)
+    Puppet::Node::Environment.stubs(:current).returns nil
+    generate = Puppet::Parser::Functions.function(:generate)
 
-        scope = mkscope
-        parser = scope.compiler.parser
+    scope = mkscope
+    parser = mkparser
 
-        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")
+    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_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 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
+    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
+    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