puppet 0.18.4 → 0.22.4

data/test/executables/puppetbin.rb

@@ -1,17 +1,11 @@
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
-require 'puppet'
-require 'puppet/server'
-require 'puppet/sslcertificates'
-require 'test/unit'
-require 'puppettest.rb'
+require 'puppettest'
 
 class TestPuppetBin < Test::Unit::TestCase
-	include ExeTest
+    include PuppetTest::ExeTest
     def test_version
         output = nil
         assert_nothing_raised {
@@ -67,6 +61,28 @@ class TestPuppetBin < Test::Unit::TestCase
 
         assert(FileTest.exists?(path), "Failed to create config'ed file")
     end
+
+    def test_stdin_execution
+        path = tempfile()
+        manifest = tempfile()
+        env = %x{which env}.chomp
+        if env == ""
+            Puppet.info "cannot find env; cannot test stdin_execution"
+            return
+        end
+        File.open(manifest, "w") do |f|
+            f.puts "#!#{env} puppet
+            file { '#{path}': ensure => file }"
+        end
+        File.chmod(0755, manifest)
+
+        assert_nothing_raised {
+            out = %x{#{manifest} 2>&1}
+        }
+        assert($? == 0, "manifest exited with code %s" % $?.to_i)
+
+        assert(FileTest.exists?(path), "Failed to create config'ed file")
+    end
 end
 
-# $Id: puppetbin.rb 1256 2006-06-13 15:57:06Z luke $
+# $Id: puppetbin.rb 2259 2007-03-06 19:03:05Z luke $

data/test/executables/puppetca.rb

@@ -1,17 +1,21 @@
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
-require 'puppet'
-require 'puppet/server'
-require 'puppet/sslcertificates'
-require 'test/unit'
-require 'puppettest.rb'
+require 'puppettest'
 
 class TestPuppetCA < Test::Unit::TestCase
-	include ExeTest
+    include PuppetTest::ExeTest
+    
+    def gen_cert(ca, host)
+        runca("-g #{host}")
+        ca.getclientcert(host)[0]
+    end
+    
+    def mkca
+        Puppet::Network::Handler.ca.new()
+    end
+    
     def mkcert(hostname)
         cert = nil
         assert_nothing_raised {
@@ -30,60 +34,77 @@ class TestPuppetCA < Test::Unit::TestCase
             debug = "-d "
         end
         return %x{puppetca --user=#{Puppet[:user]} #{debug} --group=#{Puppet[:group]} --confdir=#{Puppet[:confdir]} --vardir=#{Puppet[:vardir]} #{args} 2>&1}
-
     end
 
     def test_signing
-        ca = nil
+        ca = mkca
         Puppet[:autosign] = false
-        assert_nothing_raised {
-            ca = Puppet::Server::CA.new()
-        }
-        #Puppet.warning "SSLDir is %s" % Puppet[:confdir]
-        #system("find %s" % Puppet[:confdir])
-
-        cert = mkcert("host.test.com")
-        resp = nil
-        assert_nothing_raised {
-            # We need to use a fake name so it doesn't think the cert is from
-            # itself.
-            resp = ca.getcert(cert.csr.to_pem, "fakename", "127.0.0.1")
-        }
-        assert_equal(["",""], resp)
-        #Puppet.warning "SSLDir is %s" % Puppet[:confdir]
-        #system("find %s" % Puppet[:confdir])
+        
+        %w{host.test.com Other.Testing.Com}.each do |host|
+            cert = mkcert(host)
+            resp = nil
+            assert_nothing_raised {
+                # We need to use a fake name so it doesn't think the cert is from
+                # itself.  Strangely, getcert stores the csr, because it's a server-side
+                # method, not client.
+                resp = ca.getcert(cert.csr.to_pem, host, "127.0.0.1")
+            }
+            assert_equal(["",""], resp)
 
-        output = nil
-        assert_nothing_raised {
-            output = runca("--list").chomp.split("\n").reject { |line| line =~ /warning:/ } # stupid ssl.rb
-        }
-        #Puppet.warning "SSLDir is %s" % Puppet[:confdir]
-        #system("find %s" % Puppet[:confdir])
-        assert_equal($?,0)
-        assert_equal(%w{host.test.com}, output)
-        assert_nothing_raised {
-            output = runca("--sign -a").chomp.split("\n")
-        }
+            output = nil
+            assert_nothing_raised {
+                output = runca("--list").chomp.split("\n").reject { |line| line =~ /warning:/ } # stupid ssl.rb
+            }
+            assert_equal($?,0)
+            assert_equal([host.downcase], output)
+            assert_nothing_raised {
+                output = runca("--sign -a").chomp.split("\n")
+            }
 
 
-        assert_equal($?,0)
-        assert_equal(["Signed host.test.com"], output)
+            assert_equal($?,0)
+            assert_equal(["Signed #{host.downcase}"], output)
 
-        signedfile = File.join(Puppet[:signeddir], "host.test.com.pem")
-        assert(FileTest.exists?(signedfile), "cert does not exist")
-        assert(! FileTest.executable?(signedfile), "cert is executable")
+            
+            signedfile = ca.ca.host2certfile(host)
+            assert(FileTest.exists?(signedfile), "cert does not exist")
+            assert(! FileTest.executable?(signedfile), "cert is executable")
 
-        uid = Puppet::Util.uid(Puppet[:user])
+            uid = Puppet::Util.uid(Puppet[:user])
 
-        if Process.uid == 0
-            assert(! FileTest.owned?(signedfile), "cert is owned by root")
+            if Puppet::Util::SUIDManager.uid == 0
+                assert(! FileTest.owned?(signedfile), "cert is owned by root")
+            end
+            assert_nothing_raised {
+                output = runca("--list").chomp.split("\n")
+            }
+            assert_equal($?,0)
+            assert_equal(["No certificates to sign"], output)
         end
-        assert_nothing_raised {
-            output = runca("--list").chomp.split("\n")
-        }
-        assert_equal($?,0)
-        assert_equal(["No certificates to sign"], output)
+    end
+    
+    # This method takes a long time to run because of all of the external
+    # executable calls.
+    def test_revocation
+        ca = Puppet::SSLCertificates::CA.new()
+        host1 = gen_cert(ca, "host1.example.com")
+        host2 = gen_cert(ca, "host2.example.com")
+        host3 = gen_cert(ca, "host3.example.com")
+        runca("-r host1.example.com")
+        runca("-r #{host2.serial}")
+        runca("-r 0x#{host3.serial.to_s(16)}")
+        runca("-r 0xff")
+
+        # Recreate CA to force reading of CRL
+        ca = Puppet::SSLCertificates::CA.new()
+        crl = ca.crl
+        revoked = crl.revoked.collect { |r| r.serial }
+        exp = [host1.serial, host2.serial, host3.serial, 255]
+        assert_equal(exp, revoked)
+    end
+    
+    def test_case_insensitive_sign
     end
 end
 
-# $Id: puppetca.rb 1256 2006-06-13 15:57:06Z luke $
+# $Id: puppetca.rb 2259 2007-03-06 19:03:05Z luke $

data/test/executables/puppetd.rb

@@ -1,34 +1,31 @@
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
-require 'puppet/server'
-require 'test/unit'
-require 'puppettest.rb'
+require 'puppet/network/client'
+require 'puppettest'
 require 'socket'
 require 'facter'
 
 class TestPuppetDExe < Test::Unit::TestCase
-	include ExeTest
+    include PuppetTest::ExeTest
     def test_normalstart
         # start the master
         file = startmasterd
 
         # create the client
-        client = Puppet::Client::MasterClient.new(:Server => "localhost", :Port => @@port)
+        client = Puppet::Network::Client.master.new(:Server => "localhost", :Port => @@port)
 
         # make a new fqdn
-        fqdn = client.fqdn.sub(/^\w+\./, "testing.")
+        fqdn = Puppet[:certname].sub(/^\w+\./, "testing.")
 
         cmd = "puppetd"
         cmd += " --verbose"
         cmd += " --onetime"
-        #cmd += " --fqdn %s" % fqdn
         cmd += " --masterport %s" % @@port
         cmd += " --confdir %s" % Puppet[:confdir]
+        cmd += " --rundir %s" % File.join(Puppet[:vardir], "run")
         cmd += " --vardir %s" % Puppet[:vardir]
         cmd += " --server localhost"
 
@@ -59,4 +56,4 @@ class TestPuppetDExe < Test::Unit::TestCase
     end
 end
 
-# $Id: puppetd.rb 1256 2006-06-13 15:57:06Z luke $
+# $Id: puppetd.rb 2259 2007-03-06 19:03:05Z luke $

data/test/executables/puppetmasterd.rb

@@ -1,19 +1,14 @@
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
-require 'puppet/server'
-require 'puppet/daemon'
-require 'test/unit'
-require 'puppettest.rb'
+require 'puppet/network/client'
+require 'puppettest'
 require 'socket'
-require 'facter'
 
 class TestPuppetMasterD < Test::Unit::TestCase
-	include ExeTest
+    include PuppetTest::ExeTest
     def getcerts
         include Puppet::Daemon
         if self.readcerts
@@ -38,7 +33,7 @@ class TestPuppetMasterD < Test::Unit::TestCase
 
         client = nil
         assert_nothing_raised() {
-            client = Puppet::Client::StatusClient.new(
+            client = Puppet::Network::Client.status.new(
                 :Server => "localhost",
                 :Port => @@port
             )
@@ -50,14 +45,14 @@ class TestPuppetMasterD < Test::Unit::TestCase
 
         FileUtils.mkdir_p(File.dirname(Puppet[:autosign]))
         File.open(Puppet[:autosign], "w") { |f|
-            f.puts client.fqdn
+            f.puts Puppet[:certname]
         }
 
         retval = nil
 
         # init the client certs
         assert_nothing_raised() {
-            client.initcerts
+            client.cert
         }
 
         # call status
@@ -68,7 +63,7 @@ class TestPuppetMasterD < Test::Unit::TestCase
 
         # this client shoulduse the same certs
         assert_nothing_raised() {
-            client = Puppet::Client::MasterClient.new(
+            client = Puppet::Network::Client.master.new(
                 :Server => "localhost",
                 :Port => @@port
             )
@@ -101,7 +96,7 @@ class TestPuppetMasterD < Test::Unit::TestCase
     end
 
     def disabled_test_sslconnection
-        #file = File.join($puppetbase, "examples", "code", "head")
+        #file = File.join(exampledir, "code", "head")
         #startmasterd("--manifest #{file}")
 
         #assert_nothing_raised {
@@ -145,4 +140,4 @@ class TestPuppetMasterD < Test::Unit::TestCase
     end
 end
 
-# $Id: puppetmasterd.rb 1304 2006-06-20 18:10:06Z luke $
+# $Id: puppetmasterd.rb 2259 2007-03-06 19:03:05Z luke $

data/test/executables/puppetmodule.rb

@@ -1,22 +1,20 @@
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
 
-require 'puppet'
-require 'puppet/server'
-require 'puppet/sslcertificates'
-require 'test/unit'
-require 'puppettest.rb'
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
-$module = File.join($puppetbase, "ext", "module_puppet")
+require 'puppettest'
 
 class TestPuppetModule < Test::Unit::TestCase
-	include ExeTest
+    include PuppetTest::ExeTest
+
+
+    def setup
+        super
+        @module = File.join(basedir, "ext", "module_puppet")
+    end
 
     def test_existence
-        assert(FileTest.exists?($module), "Module does not exist")
+        assert(FileTest.exists?(@module), "Module does not exist")
     end
 
     def test_execution
@@ -29,7 +27,7 @@ class TestPuppetModule < Test::Unit::TestCase
         }
 
         output = nil
-        cmd = $module
+        cmd = @module
         cmd += " --verbose"
         #cmd += " --fqdn %s" % fqdn
         cmd += " --confdir %s" % Puppet[:confdir]
@@ -37,19 +35,22 @@ class TestPuppetModule < Test::Unit::TestCase
         if Puppet[:debug]
             cmd += " --logdest %s" % "console"
             cmd += " --debug"
+            cmd += " --trace"
         else
             cmd += " --logdest %s" % "/dev/null"
         end
 
         ENV["CFALLCLASSES"] = "yaytest:all"
+        libsetup
 
+        out = nil
         assert_nothing_raised {
-            %x{#{cmd + " " + file} 2>&1}
+            out = %x{#{cmd + " " + file} 2>&1}
         }
-        assert($? == 0, "Puppet module exited with code %s" % $?.to_i)
+        assert($? == 0, "Puppet module exited with code %s: %s" % [$?.to_i, out])
 
         assert(FileTest.exists?(createdfile), "Failed to create config'ed file")
     end
 end
 
-# $Id: puppetmodule.rb 1256 2006-06-13 15:57:06Z luke $
+# $Id: puppetmodule.rb 2259 2007-03-06 19:03:05Z luke $

data/test/language/ast.rb

@@ -1,893 +1,337 @@
-#!/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/rails'
 require 'puppet/parser/interpreter'
 require 'puppet/parser/parser'
-require 'puppet/client'
-require 'test/unit'
+require 'puppet/network/client'
 require 'puppettest'
+require 'puppettest/resourcetesting'
+require 'puppettest/parsertesting'
+require 'puppettest/railstesting'
 
 class TestAST < Test::Unit::TestCase
-	include ParserTesting
-
-    # Test that classes behave like singletons
-    def test_classsingleton
-        parent = child1 = child2 = nil
-        children = []
-
-        # create the parent class
-        children << classobj("parent")
-
-        # Create child class one
-        children << classobj("child1", :parentclass => nameobj("parent"))
-
-        # Create child class two
-        children << classobj("child2", :parentclass => nameobj("parent"))
-        classes = %w{parent child1 child2}
-
-        # Now call the two classes
-        assert_nothing_raised("Could not add AST nodes for calling") {
-            children << AST::ObjectDef.new(
-                :type => nameobj("child1"),
-                :name => nameobj("yayness"),
-                :params => astarray()
-            )
-            children << AST::ObjectDef.new(
-                :type => nameobj("child2"),
-                :name => nameobj("booness"),
-                :params => astarray()
-            )
-        }
-
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
-        }
-
-        scope = nil
-        objects = nil
-        assert_nothing_raised("Could not evaluate") {
-            scope = Puppet::Parser::Scope.new()
-            objects = scope.evaluate(:ast => top)
-        }
-
-        assert_instance_of(Puppet::TransBucket, objects)
-
-        assert_equal(1, scope.find_all { |child|
-            if child.is_a? Puppet::Parser::Scope
-                child.lookupobject(:name => "/parent", :type => "file")
+    include PuppetTest::RailsTesting
+    include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
+    
+    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
-                nil
-            end
-        }.length, "Found incorrect number of '/parent' objects")
-
-        assert_equal(classes.sort, scope.classlist.sort)
-    end
-
-    # Test that 'tagobject' collects all of an object's parameters and stores
-    # them in one TransObject, rather than many.  This is probably a bad idea.
-    def test_tagobject
-        top = nil
-        children = [
-            fileobj("/etc", "owner" => "root"),
-            fileobj("/etc", "group" => "root")
-        ]
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
-        }
-
-        scope = Puppet::Parser::Scope.new()
-        assert_nothing_raised("Could not evaluate") {
-            top.evaluate(:scope => scope)
-        }
-
-        obj = nil
-        assert_nothing_raised("Could not retrieve file object") {
-            obj = scope.lookupobject(:name => "/etc", :type => "file")
-        }
-
-        assert(obj, "could not retrieve file object")
-
-        %w{owner group}.each { |param|
-            assert(obj.include?(param), "Object did not include %s" % param)
-        }
-
-    end
-
-    # Verify that objects can only have parents of the same type.
-    def test_validparent
-        parent = child1 = nil
-        children = []
-
-        # create the parent class
-        children << compobj("parent", :args => AST::ASTArray.new(:children => []))
-
-        # Create child class one
-        children << classobj("child1", :parentclass => nameobj("parent"))
-
-        # Now call the two classes
-        assert_nothing_raised("Could not add AST nodes for calling") {
-            children << AST::ObjectDef.new(
-                :type => nameobj("child1"),
-                :name => nameobj("yayness"),
-                :params => astarray()
-            )
-        }
-
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
-        }
-
-        scope = nil
-        assert_raise(Puppet::ParseError, "Invalid parent type was allowed") {
-            scope = Puppet::Parser::Scope.new()
-            objects = scope.evaluate(:ast => top)
-        }
-    end
-
-    # Verify that nodes don't evaluate code in other node scopes but that their
-    # facts work outside their scopes.
-    def test_nodescopes
-        parent = child1 = nil
-        topchildren = []
-
-        # create the parent class
-        topchildren << classobj("everyone")
-
-        topchildren << classobj("parent")
-
-
-        classes = %w{everyone parent}
-
-        # And a variable, so we verify the facts get set at the top
-        assert_nothing_raised {
-            children = []
-            children << varobj("yaytest", "$hostname")
-        }
-
-        nodes = []
-
-        3.times do |i|
-            children = []
-
-            # Create a child class
-            topchildren << classobj("perchild#{i}", :parentclass => nameobj("parent"))
-            classes << "perchild%s"
-
-            # Create a child class
-            children << classobj("child", :parentclass => nameobj("parent"))
-
-            classes << "child"
-
-            ["child", "everyone", "perchild#{i}"].each do |name|
-                # Now call our child class
-                assert_nothing_raised {
-                    children << AST::ObjectDef.new(
-                        :type => nameobj(name),
-                        :params => astarray()
-                    )
-                }
-            end
-
-            # and another variable
-            assert_nothing_raised {
-                children << varobj("rahtest", "$hostname")
-            }
-
-            # create the node
-            nodename = "node#{i}"
-            nodes << nodename
-            assert_nothing_raised("Could not create parent object") {
-                topchildren << AST::NodeDef.new(
-                    :names => nameobj(nodename),
-                    :code => AST::ASTArray.new(
-                        :children => children
-                    )
-                )
-            }
-        end
-
-        # Create the wrapper object
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => topchildren
-            )
-        }
-
-        nodes.each_with_index do |node, i|
-            # Evaluate the parse tree
-            scope = Puppet::Parser::Scope.new()
-            args = {:names => [node], :facts => {"hostname" => node}, :ast => top}
-
-            # verify that we can evaluate it okay
-            trans = nil
-            assert_nothing_raised("Could not retrieve node definition") {
-                trans = scope.evaluate(args)
-            }
-
-            assert_equal(node, scope.lookupvar("hostname"))
-
-            assert(trans, "Could not retrieve trans objects")
-
-            # and that we can convert them to type objects
-            objects = nil
-            assert_nothing_raised("Could not retrieve node definition") {
-                objects = trans.to_type
-            }
-
-            assert(objects, "Could not retrieve trans objects")
-
-            count = 0
-            # Make sure the node name gets into the path correctly.
-            Puppet.type(:file).each { |obj|
-                count += 1
-                assert(obj.path !~ /#{node}\[#{node}\]/,
-                    "Node name appears twice")
-            }
-
-            assert(count > 0, "Did not create any files")
-
-            classes.each do |name|
-                if name =~ /%s/
-                    name = name % i
-                end
-                assert(Puppet::Type.type(:file)["/#{name}"], "Could not find '#{name}'")
+                non << object
             end
-            Puppet::Type.allclear
         end
-    end
-
-    # Verify that classes are correctly defined in node scopes.
-    def disabled_test_nodeclasslookup
-        parent = child1 = nil
-        children = []
-
-        # create the parent class
-        children << classobj("parent")
-
-        # Create child class one
-        children << classobj("child1", :parentclass => nameobj("parent"))
-
-        # Now call the two classes
-        assert_nothing_raised("Could not add AST nodes for calling") {
-            children << AST::ObjectDef.new(
-                :type => nameobj("child1"),
-                :name => nameobj("yayness"),
-                :params => astarray()
-            )
-        }
-
-        # create the node
-        nodename = "mynodename"
-        node = nil
-        assert_nothing_raised("Could not create parent object") {
-            node = AST::NodeDef.new(
-                :names => nameobj(nodename),
-                :code => AST::ASTArray.new(
-                    :children => children
-                )
-            )
-        }
 
-        # Create the wrapper object
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => [node]
-            )
-        }
-
-        # Evaluate the parse tree
-        scope = nil
-        assert_nothing_raised("Could not evaluate node") {
-            scope = Puppet::Parser::Scope.new()
-            top.evaluate(:scope => scope)
-        }
-
-        # Verify that, well, nothing really happened, and especially verify
-        # that the top scope is not a node scope
-        assert(scope.topscope?, "Scope is not top scope")
-        assert(! scope.nodescope?, "Scope is mistakenly node scope")
-        assert(! scope.lookupclass("parent"), "Found parent class in top scope")
-
-        # verify we can find our node
-        assert(scope.node(nodename), "Could not find node")
-
-        # And verify that we can evaluate it okay
-        objects = nil
-        assert_nothing_raised("Could not retrieve node definition") {
-            objects = scope.evalnode(:name => [nodename], :facts => {})
-        }
-
-        assert(objects, "Could not retrieve node definition")
+        # Now collect our facts
+        facts = {}
+        Facter.each do |fact, value| facts[fact] = value end
 
-        # Because node scopes are temporary (i.e., they get destroyed after the node's
-        # config is returned) we should not be able to find the node scope.
-        nodescope = nil
         assert_nothing_raised {
-            nodescope = scope.find { |child|
-                child.nodescope?
-            }
-        }
-
-        assert_nil(nodescope, "Found nodescope")
-
-        # And now verify again that the top scope cannot find the node's definition
-        # of the parent class
-        assert(! scope.lookupclass("parent"), "Found parent class in top scope")
-
-        trans = nil
-        # Verify that we can evaluate the node twice
-        assert_nothing_raised("Could not retrieve node definition") {
-            trans = scope.evalnode(:name => [nodename], :facts => {})
-        }
-
-        objects = nil
-        assert_nothing_raised("Could not convert to objects") {
-            objects = trans.to_type
-        }
-
-        Puppet.type(:file).each { |obj|
-            assert(obj.path !~ /#{nodename}\[#{nodename}\]/,
-                "Node name appears twice")
-        }
-
-        assert(Puppet::Type.type(:file)["/child1"], "Could not find child")
-        assert(Puppet::Type.type(:file)["/parent"], "Could not find parent")
-    end
-
-    # Test that you can look a host up using multiple names, e.g., an FQDN and
-    # a short name
-    def test_multiplenodenames
-        children = []
-
-        # create a short-name node
-        shortname = "mynodename"
-        children << nodedef(shortname)
-
-        # And a long-name node
-        longname = "node.domain.com"
-        children << nodedef(longname)
-
-        # Create the wrapper object
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
+            Puppet::Rails.init
         }
 
-        # Evaluate the parse tree
-        scope = Puppet::Parser::Scope.new()
-
-        # Verify we can find the node via a search list
-        objects = nil
-        assert_nothing_raised("Could not retrieve short node definition") {
-            objects = scope.evaluate(
-                :names => ["%s.domain.com" % shortname, shortname], :facts => {},
-                :ast => top
+        # Now try storing our crap
+        assert_nothing_raised {
+            host = Puppet::Rails::Host.store(
+                :objects => bucket,
+                :facts => facts,
+                :host => facts["hostname"]
             )
         }
-        assert(objects, "Could not retrieve short node definition")
-
-        scope = Puppet::Parser::Scope.new()
 
-        # and then look for the long name
-        assert_nothing_raised("Could not retrieve long node definition") {
-            objects = scope.evaluate(
-                :names => [longname.sub(/\..+/, ''), longname], :facts => {},
-                :ast => top
+        # 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")
             )
         }
-        assert(objects, "Could not retrieve long node definition")
-    end
-
-    # Test that a node gets the entire configuration except for work meant for
-    # another node
-    def test_fullconfigwithnodes
-        children = []
-
-        children << fileobj("/testing")
-
-        # create a short-name node
-        name = "mynodename"
-        children << nodedef(name)
 
-        # Create the wrapper object
         top = nil
         assert_nothing_raised("Could not create top object") {
             top = AST::ASTArray.new(
-                :children => children
+                :children => [coll]
             )
         }
 
-        scope = Puppet::Parser::Scope.new()
-
-        # Verify we can find the node via a search list
         objects = nil
-        assert_nothing_raised("Could not retrieve short node definition") {
-            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 evaluate") {
+            scope = mkscope
+            objects = scope.evaluate(:ast => top).flatten
         }
 
-        assert_nothing_raised("Could not find node-declared object %s" %
-            "/%s" % name
-        ) {
-            assert_equal("/%s" % name, objects[1][0].name)
-        }
+        assert(objects.length > 0, "Did not receive any collected objects")
     end
-
-    # Test that we can 'include' variables, not just normal strings.
-    def test_includevars
-        children = []
-        classes = []
-
-        # Create our class for testin
-        klassname = "include"
-        children << classobj(klassname)
-        classes << klassname
-
-        # Then add our variable assignment
-        children << varobj("klassvar", klassname)
-
-        # And finally add our calling of the variable
-        children << AST::ObjectDef.new(
-            :type => AST::Variable.new(:value => "klassvar"),
-            :params => astarray
-        )
-
-        # And then create our top object
-        top = AST::ASTArray.new(
-            :children => children
-        )
-
-        # Evaluate the parse tree
-        scope = nil
-        objects = nil
-        assert_nothing_raised("Could not evaluate node") {
-            scope = Puppet::Parser::Scope.new()
-            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
-        #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") {
-            assert_equal("/%s" % klassname, objects[0][0].name)
-        }
+    else
+        $stderr.puts "No ActiveRecord -- skipping collection tests"
     end
 
-    # Test that node inheritance works correctly
-    def test_nodeinheritance
-        children = []
-
-        # create the base node
-        name = "basenode"
-        children << nodedef(name)
-
-        # and the sub node
-        name = "subnode"
-        children << AST::NodeDef.new(
-            :names => nameobj(name),
-            :parentclass => nameobj("basenode"),
-            :code => AST::ASTArray.new(
-                :children => [
-                    varobj("%svar" % name, "%svalue" % name),
-                    fileobj("/%s" % name)
-                ]
-            )
-        )
-        #subnode = nodedef(name)
-        #subnode.parentclass = "basenode"
-
-        #children << subnode
+    def test_if
+        astif = nil
+        astelse = nil
+        fakeelse = FakeAST.new(:else)
+        faketest = FakeAST.new(true)
+        fakeif = FakeAST.new(:if)
 
-        # and the top object
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
+        assert_nothing_raised {
+            astelse = AST::Else.new(:statements => fakeelse)
+        }
+        assert_nothing_raised {
+            astif = AST::IfStatement.new(
+                :test => faketest,
+                :statements => fakeif,
+                :else => astelse
             )
         }
 
-        # Evaluate the parse tree
-        scope = Puppet::Parser::Scope.new()
-
-        # Verify we can find the node via a search list
-        objects = nil
-        assert_nothing_raised("Could not evaluate node") {
-            objects = scope.evaluate(:names => [name], :facts => {}, :ast => top)
+        # We initialized it to true, so we should get that first
+        ret = nil
+        assert_nothing_raised {
+            ret = astif.evaluate(:scope => "yay")
         }
-        assert(objects, "Could not retrieve node definition")
+        assert_equal(:if, ret)
 
+        # Now set it to false and check that
+        faketest.evaluate = false
         assert_nothing_raised {
-            inner = objects[0]
-
-            # And now verify that we got the subnode file
-            assert_nothing_raised("Could not find basenode file") {
-                base = inner[0]
-                assert_equal("/basenode", base.name)
-            }
-
-            # and the parent node file
-            assert_nothing_raised("Could not find subnode file") {
-                sub = inner[1]
-                assert_equal("/subnode", sub.name)
-            }
-
-            inner.each { |obj|
-                %w{basenode subnode}.each { |tag|
-                    assert(obj.tags.include?(tag),
-                        "%s did not include %s tag" % [obj.name, tag]
-                    )
-                }
-            }
+            ret = astif.evaluate(:scope => "yay")
         }
+        assert_equal(:else, ret)
     end
 
-    def test_typechecking
-        object = nil
-        children = []
-        type = "deftype"
-        assert_nothing_raised("Could not add AST nodes for calling") {
-            object = AST::ObjectDef.new(
-                :type => nameobj(type),
-                :name => nameobj("yayness"),
-                :params => astarray()
-            )
-        }
-
-        assert_nothing_raised("Typecheck failed") {
-            object.typecheck(type)
-        }
+    # Make sure our override object behaves "correctly"
+    def test_override
+        interp, scope, source = mkclassframing
 
-        # Add a scope, which makes it think it's evaluating
-        assert_nothing_raised {
-            scope = Puppet::Parser::Scope.new()
-            object.scope = scope
-        }
+        ref = nil
+        assert_nothing_raised do
+            ref = resourceoverride("resource", "yaytest", "one" => "yay", "two" => "boo")
+        end
 
-        # Verify an error is thrown when it can't find the type
-        assert_raise(Puppet::ParseError) {
-            object.typecheck(type)
-        }
+        ret = nil
+        assert_nothing_raised do
+            ret = ref.evaluate :scope => scope
+        end
 
-        # Create child class one
-        children << classobj(type)
-        children << object
+        assert_instance_of(Puppet::Parser::Resource, ret)
 
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
-        }
+        assert(ret.override?, "Resource was not an override resource")
 
-        scope = nil
-        assert_nothing_raised("Could not evaluate") {
-            scope = Puppet::Parser::Scope.new()
-            objects = top.evaluate(:scope => scope)
-        }
+        assert(scope.overridetable[ret.ref].include?(ret),
+            "Was not stored in the override table")
     end
 
-    def disabled_test_paramcheck
-        object = nil
-        children = []
-        type = "deftype"
-        params = %w{param1 param2}
-
-        comp = compobj(type, {
-            :args => astarray(
-                argobj("param1", "yay"),
-                argobj("param2", "rah")
-            ),
-            :code => AST::ASTArray.new(
-                :children => [
-                    varobj("%svar" % name, "%svalue" % name),
-                    fileobj("/%s" % name)
-                ]
-            )
-        })
-        assert_nothing_raised("Could not add AST nodes for calling") {
-            object = AST::ObjectDef.new(
-                :type => nameobj(type),
-                :name => nameobj("yayness"),
-                :params => astarray(
-                    astarray(stringobj("param1"), stringobj("value1")),
-                    astarray(stringobj("param2"), stringobj("value2"))
-                )
-            )
-        }
+    # make sure our resourcedefaults ast object works correctly.
+    def test_resourcedefaults
+        interp, scope, source = mkclassframing
 
-        # Add a scope, which makes it think it's evaluating
-        assert_nothing_raised {
-            scope = Puppet::Parser::Scope.new()
-            object.scope = scope
-        }
-
-        # Verify an error is thrown when it can't find the type
-        assert_raise(Puppet::ParseError) {
-            object.paramcheck(false, comp)
-        }
+        # Now make some defaults for files
+        args = {:source => "/yay/ness", :group => "yayness"}
+        assert_nothing_raised do
+            obj = defaultobj "file", args
+            obj.evaluate :scope => scope
+        end
 
-        # Create child class one
-        children << classobj(type)
-        children << object
+        hash = nil
+        assert_nothing_raised do
+            hash = scope.lookupdefaults("file")
+        end
 
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
-        }
+        hash.each do |name, value|
+            assert_instance_of(Symbol, name) # params always convert
+            assert_instance_of(Puppet::Parser::Resource::Param, value)
+        end
 
-        scope = nil
-        assert_nothing_raised("Could not evaluate") {
-            scope = Puppet::Parser::Scope.new()
-            objects = top.evaluate(:scope => scope)
-        }
+        args.each do |name, value|
+            assert(hash[name], "Did not get default %s" % name)
+            assert_equal(value, hash[name].value)
+        end
     end
 
-    def test_setclass
-        type = "yay"
-        classes = [type]
-        children = []
-        # Create child class one
-        children << varobj("variable", "aclass")
-        children << tagobj(type, varref("variable"))
-        children << tagobj(type)
+    def test_node
+        interp = mkinterp
+        scope = mkscope(:interp => interp)
 
-        classes << "aclass"
+        # Define a base node
+        basenode = interp.newnode "basenode", :code => AST::ASTArray.new(:children => [
+            resourcedef("file", "/tmp/base", "owner" => "root")
+        ])
 
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
-        }
+        # Now define a subnode
+        nodes = interp.newnode ["mynode", "othernode"],
+            :code => AST::ASTArray.new(:children => [
+                resourcedef("file", "/tmp/mynode", "owner" => "root"),
+                resourcedef("file", "/tmp/basenode", "owner" => "daemon")
+        ])
 
-        scope = nil
-        assert_nothing_raised("Could not evaluate") {
-            scope = Puppet::Parser::Scope.new()
-            objects = top.evaluate(:scope => scope)
-        }
+        assert_instance_of(Array, nodes)
 
-
-        classes.each do |tag|
-            assert(scope.classlist.include?(tag), "Did not set class %s" % tag)
+        # Make sure we can find them all.
+        %w{mynode othernode}.each do |node|
+            assert(interp.nodesearch_code(node), "Could not find %s" % node)
         end
+        mynode = interp.nodesearch_code("mynode")
 
-    end
+        # Now try evaluating the node
+        assert_nothing_raised do
+            mynode.evaluate :scope => scope
+        end
 
-    # Test that we strip the domain off of host names before they are set as classes
-    def test_nodenamestrip
-        children = []
+        # Make sure that we can find each of the files
+        myfile = scope.findresource "File[/tmp/mynode]"
+        assert(myfile, "Could not find file from node")
+        assert_equal("root", myfile[:owner])
 
-        longname = "node.domain.com"
-        children << nodedef(longname)
+        basefile = scope.findresource "File[/tmp/basenode]"
+        assert(basefile, "Could not find file from base node")
+        assert_equal("daemon", basefile[:owner])
 
-        # Create the wrapper object
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
-        }
+        # Now make sure we can evaluate nodes with parents
+        child = interp.newnode(%w{child}, :parent => "basenode").shift
 
-        scope = Puppet::Parser::Scope.new()
-
-        assert_nothing_raised("Could not evaluate node") {
-            objects = scope.evaluate(:names => [longname], :facts => {}, :ast => top)
-        }
+        newscope = mkscope :interp => interp
+        assert_nothing_raised do
+            child.evaluate :scope => newscope
+        end
 
-        assert(!scope.classlist.include?("node.domain.com"),
-            "Node's long name got set")
-        assert(scope.classlist.include?("node"), "Node's name did not get set")
+        assert(newscope.findresource("File[/tmp/base]"),
+            "Could not find base resource")
     end
 
-    # Make sure that deep class parentage works
-    def test_classparentage
-        children = []
-        files = []
-        base = classobj("base")
-        files << "/base"
+    def test_collection
+        interp = mkinterp
+        scope = mkscope(:interp => interp)
 
-        children << base
+        coll = nil
+        assert_nothing_raised do
+            coll = AST::Collection.new(:type => "file", :form => :virtual)
+        end
 
-        parent = "base"
-        5.times { |i|
-            name = "child%s" % i
-            files << "/%s" % name
-            children << classobj(name, :parentclass => nameobj(parent))
+        assert_instance_of(AST::Collection, coll)
 
-            parent = name
-        }
+        ret = nil
+        assert_nothing_raised do
+            ret = coll.evaluate :scope => scope
+        end
 
-        children << functionobj("include", parent)
+        assert_instance_of(Puppet::Parser::Collector, ret)
 
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
-        }
+        # Now make sure we get it back from the scope
+        assert_equal([ret], scope.collections)
+    end
 
-        objects = nil
-        assert_nothing_raised("Could not evaluate") {
-            scope = Puppet::Parser::Scope.new()
-            objects = scope.evaluate(:ast => top)
-        }
+    def test_virtual_collexp
+        @interp, @scope, @source = mkclassframing
+
+        # make a resource
+        resource = mkresource(:type => "file", :title => "/tmp/testing",
+            :params => {:owner => "root", :group => "bin", :mode => "644"})
 
-        objects = objects.flatten
+        run_collection_queries(:virtual) do |string, result, query|
+            code = nil
+            assert_nothing_raised do
+                str, code = query.evaluate :scope => @scope
+            end
 
-        files.each do |file|
-            assert(objects.find { |o| o.name == file },
-                "Could not find file %s" % file)
+            assert_instance_of(Proc, code)
+            assert_nothing_raised do
+                assert_equal(result, code.call(resource),
+                    "'#{string}' failed")
+            end
         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
+    if defined? ActiveRecord::Base
+    def test_exported_collexp
+        railsinit
+        Puppet[:storeconfigs] = true
+        @interp, @scope, @source = mkclassframing
+
+        # make a rails resource
+        railsresource "file", "/tmp/testing", :owner => "root", :group => "bin",
+            :mode => "644" 
+
+        run_collection_queries(:exported) do |string, result, query|
+            code = nil
+            str = nil
+
+            # We don't support anything but the title in rails right now
+            retval = nil
+            bad = false
+            # Figure out if the search is for anything rails will ignore
+            string.scan(/(\w+) [!=]= \w+/) do |s|
+                unless s[0] == "title"
+                    bad = true
+                    break
+                end
+            end
 
-        trans = nil
-        assert_nothing_raised {
-            trans = scope.evaluate(:ast => obj, :facts => {})
-        }
+            # And if it is, make sure we throw an error.
+            if bad
+                assert_raise(Puppet::ParseError, "Evaluated '#{string}'") do
+                    str, code = query.evaluate :scope => @scope
+                end
+                next
+            else
+                assert_nothing_raised("Could not evaluate '#{string}'") do
+                    str, code = query.evaluate :scope => @scope
+                end
+            end
+            assert_nothing_raised("Could not find resource") do
+                retval = Puppet::Rails::Resource.find(:all,
+                    :include => :param_values,
+                    :conditions => str) 
+            end
 
-        transobj = trans.shift
-        assert(transobj.name, "Name did not convert from param to name")
-    end
+            if result
+                assert_equal(1, retval.length, "Did not find resource with '#{string}'")
+                res = retval.shift
 
-    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
+                assert_equal("file", res.restype)
+                assert_equal("/tmp/testing", res.title)
             else
-                non << object
+                assert_equal(0, retval.length, "found a resource with '#{string}'")
             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")
+    def run_collection_queries(form)
+        {true => [%{title == "/tmp/testing"}, %{(title == "/tmp/testing")},
+            %{title == "/tmp/testing" and group == bin}, %{title == bin or group == bin},
+            %{title == "/tmp/testing" or title == bin}, %{title == "/tmp/testing"},
+            %{(title == "/tmp/testing" or title == bin) and group == bin}],
+        false => [%{title == bin}, %{title == bin or (title == bin and group == bin)},
+            %{title != "/tmp/testing"}, %{title != "/tmp/testing" and group != bin}]
+        }.each do |res, ary|
+            ary.each do |str|
+                if form == :virtual
+                    code = "File <| #{str} |>"
+                else
+                    code = "File <<| #{str} |>>"
+                end
+                parser = mkparser
+                query = nil
 
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
-        }
+                assert_nothing_raised("Could not parse '#{str}'") do
+                    query = parser.parse(code)[0].query
+                end
 
-        objects = nil
-        assert_nothing_raised("Could not evaluate") {
-            scope = Puppet::Parser::Scope.new()
-            objects = scope.evaluate(:ast => top)
-        }
+                yield str, res, query
+            end
+        end
     end
 end
 
-# $Id: ast.rb 1256 2006-06-13 15:57:06Z luke $
+# $Id: ast.rb 2296 2007-03-18 22:48:57Z luke $