Small modification so i can make more changes

git-svn-id: https://reductivelabs.com/svn/puppet/trunk@1629 980ebf18-57e1-0310-9a29-db15c13687c0

2 files changed, 2 insertions, 1277 deletions

diff --git a/test/lib/puppettest.rb b/test/lib/puppettest.rb
deleted file mode 100644
index e1af58e0a..000000000
--- a/test/lib/puppettest.rb
+++ /dev/null
@@ -1,1277 +0,0 @@
-libdir = File.join(File.dirname(__FILE__), '../lib')
-unless $:.include?(libdir)
-    $:.unshift libdir
-end
-
-require 'puppet'
-require 'test/unit'
-
-################################################################################
-# OLD CODE
-################################################################################
-module TestPuppet
-    include ObjectSpace
-
-    # A baseclass for the faketypes.
-    class FakeModel < Hash
-        class << self
-            attr_accessor :name
-            @name = :fakemodel
-        end
-
-        def self.validstates
-            Puppet::Type.type(@name).validstates
-        end
-
-        def self.validstate?(name)
-            Puppet::Type.type(@name).validstate?(name)
-        end
-
-        def initialize(name)
-            self[:name] = name
-        end
-
-        def inspect
-            "%s(%s)" % [self.class.to_s.sub(/.+::/, ''), super()]
-        end
-
-        def name
-            self[:name]
-        end
-    end
-
-    class FakeProvider
-        attr_accessor :model
-        class << self
-            attr_accessor :name, :model, :methods
-        end
-
-        # A very low number, so these never show up as defaults via the standard
-        # algorithms.
-        def self.defaultnum
-            -50
-        end
-
-        # Set up methods to fake things
-        def self.apimethods(*ary)
-            @model.validstates.each do |state|
-                ary << state unless ary.include? state
-            end
-            attr_accessor(*ary)
-
-            @methods = ary
-        end
-
-        def self.initvars
-            @calls = Hash.new do |hash, key|
-                hash[key] = 0
-            end
-        end
-
-        def self.suitable?
-            true
-        end
-
-        def initialize(model)
-            @model = model
-        end
-    end
-
-    @@fakemodels = {}
-    @@fakeproviders = {}
-
-    def fakemodel(type, name, options = {})
-        type = type.intern if type.is_a? String
-        unless @@fakemodels.include? type
-            @@fakemodels[type] = Class.new(FakeModel)
-            @@fakemodels[type].name = type
-        end
-
-        obj = @@fakemodels[type].new(name)
-        obj[:name] = name
-        options.each do |name, val|
-            obj[name] = val
-        end
-        obj
-    end
-
-    def fakeprovider(type, model)
-        type = type.intern if type.is_a? String
-        unless @@fakeproviders.include? type
-            @@fakeproviders[type] = Class.new(FakeModel) do
-                @name = type
-            end
-        end
-
-        @@fakeproviders[type].new(model)
-    end
-
-    def gcdebug(type)
-        Puppet.warning "%s: %s" % [type, ObjectSpace.each_object(type) { |o| }]
-    end
-
-    def newcomp(*ary)
-        name = nil
-        if ary[0].is_a?(String)
-            name = ary.shift
-        else
-            name = ary[0].title
-        end
-
-        comp = Puppet.type(:component).create(
-            :name => name
-        )
-        ary.each { |item|
-            comp.push item
-        }
-
-        return comp
-    end
-
-    def setup
-        @memoryatstart = Puppet::Util.memory
-        if defined? @@testcount
-            @@testcount += 1
-        else
-            @@testcount = 0
-        end
-
-        @configpath = File.join(tmpdir,
-            self.class.to_s + "configdir" + @@testcount.to_s + "/"
-        )
-
-        unless defined? $user and $group
-            $user = nonrootuser().uid.to_s
-            $group = nonrootgroup().gid.to_s
-        end
-        Puppet[:user] = $user
-        Puppet[:group] = $group
-
-        Puppet[:confdir] = @configpath
-        Puppet[:vardir] = @configpath
-
-        unless File.exists?(@configpath)
-            Dir.mkdir(@configpath)
-        end
-
-        @@tmpfiles = [@configpath, tmpdir()]
-        @@tmppids = []
-
-        @@cleaners = []
-
-        if $0 =~ /.+\.rb/ or Puppet[:debug]
-            Puppet::Log.newdestination :console
-            Puppet::Log.level = :debug
-            #$VERBOSE = 1
-            Puppet.info @method_name
-        else
-            Puppet::Log.close
-            Puppet::Log.newdestination tempfile()
-            Puppet[:httplog] = tempfile()
-        end
-
-        Puppet[:ignoreschedules] = true
-    end
-
-    def newobj(type, name, hash)
-        transport = Puppet::TransObject.new(name, "file")
-        transport[:path] = path
-        transport[:ensure] = "file"
-        assert_nothing_raised {
-            file = transport.to_type
-        }
-    end
-
-    def spin
-        # Just disable spin, unless we really need it
-        return
-#        if Puppet[:debug]
-#            return
-#        end
-#        @modes = %w{| / - \\}
-#        unless defined? @mode
-#            @mode = 0
-#        end
-#
-#        $stderr.print "%s" % @modes[@mode]
-#        if @mode == @modes.length - 1
-#            @mode = 0
-#        else
-#            @mode += 1
-#        end
-#        $stderr.flush
-    end
-
-    # stop any services that might be hanging around
-    def stopservices
-        if stype = Puppet::Type.type(:service)
-            stype.each { |service|
-                service[:ensure] = :stopped
-                service.evaluate
-            }
-        end
-    end
-
-    def cleanup(&block)
-        @@cleaners << block
-    end
-
-    def setme
-        # retrieve the user name
-        id = %x{id}.chomp
-        if id =~ /uid=\d+\(([^\)]+)\)/
-            @me = $1
-        else
-            puts id
-        end
-        unless defined? @me
-            raise "Could not retrieve user name; 'id' did not work"
-        end
-    end
-
-    def teardown
-        stopservices
-
-        @@cleaners.each { |cleaner| cleaner.call() }
-
-        @@tmpfiles.each { |file|
-            if FileTest.exists?(file)
-                system("chmod -R 755 %s" % file)
-                system("rm -rf %s" % file)
-            end
-        }
-        @@tmpfiles.clear
-
-        @@tmppids.each { |pid|
-            %x{kill -INT #{pid} 2>/dev/null}
-        }
-
-        @@tmppids.clear
-        Puppet::Type.allclear
-        Puppet::Storage.clear
-        Puppet::Rails.clear
-        Puppet.clear
-
-        @memoryatend = Puppet::Util.memory
-        diff = @memoryatend - @memoryatstart
-
-        if diff > 1000
-            Puppet.info "%s#%s memory growth (%s to %s): %s" %
-                [self.class, @method_name, @memoryatstart, @memoryatend, diff]
-        end
-
-        # reset all of the logs
-        Puppet::Log.close
-
-        # Just in case there are processes waiting to die...
-        Process.waitall
-        if File.stat("/dev/null").mode & 007777 != 0666
-            File.open("/tmp/nullfailure", "w") { |f|
-                f.puts self.class
-            }
-            exit(74)
-        end
-    end
-
-    def tempfile
-        if defined? @@tmpfilenum
-            @@tmpfilenum += 1
-        else
-            @@tmpfilenum = 1
-        end
-
-        f = File.join(self.tmpdir(), self.class.to_s + "_" + @method_name +
-            @@tmpfilenum.to_s)
-        @@tmpfiles << f
-        return f
-    end
-
-    def tstdir
-        tempfile()
-    end
-
-    def tmpdir
-        unless defined? @tmpdir and @tmpdir
-            @tmpdir = case Facter["operatingsystem"].value
-            when "Darwin": "/private/tmp"
-            when "SunOS": "/var/tmp"
-            else
-                "/tmp"
-            end
-
-
-            @tmpdir = File.join(@tmpdir, "puppettesting")
-
-            unless File.exists?(@tmpdir)
-                FileUtils.mkdir_p(@tmpdir)
-                File.chmod(01777, @tmpdir)
-            end
-        end
-        @tmpdir
-    end
-
-    def assert_rollback_events(events, trans, msg = nil)
-        run_events(:rollback, events, trans, msg)
-    end
-
-    def assert_events(events, *items)
-        trans = nil
-        comp = nil
-        msg = nil
-
-        unless events.is_a? Array
-            raise Puppet::DevError, "Incorrect call of assert_events"
-        end
-        if items[-1].is_a? String
-            msg = items.pop
-        end
-
-        remove_comp = false
-        # They either passed a comp or a list of items.
-        if items[0].is_a? Puppet.type(:component)
-            comp = items.shift
-        else
-            comp = newcomp(items[0].title, *items)
-            remove_comp = true
-        end
-        msg ||= comp.title
-        assert_nothing_raised("Component %s failed" % [msg]) {
-            trans = comp.evaluate
-        }
-
-        run_events(:evaluate, trans, events, msg)
-
-        if remove_comp
-            Puppet.type(:component).delete(comp)
-        end
-
-        return trans
-    end
-
-    # A simpler method that just applies what we have.
-    def assert_apply(*objects)
-        if objects[0].is_a?(Puppet.type(:component))
-            comp = objects.shift
-            unless objects.empty?
-                objects.each { |o| comp.push o }
-            end
-        else
-            comp = newcomp(*objects)
-        end
-        trans = nil
-
-        assert_nothing_raised("Failed to create transaction") {
-            trans = comp.evaluate
-        }
-
-        events = nil
-        assert_nothing_raised("Failed to evaluate transaction") {
-            events = trans.evaluate.collect { |e| e.event }
-        }
-        Puppet.type(:component).delete(comp)
-        events
-    end
-
-    def run_events(type, trans, events, msg)
-        case type
-        when :evaluate, :rollback: # things are hunky-dory
-        else
-            raise Puppet::DevError, "Incorrect run_events type"
-        end
-
-        method = type
-
-        newevents = nil
-        assert_nothing_raised("Transaction %s %s failed" % [type, msg]) {
-            newevents = trans.send(method).reject { |e| e.nil? }.collect { |e|
-                e.event
-            }
-        }
-
-        assert_equal(events, newevents, "Incorrect %s %s events" % [type, msg])
-
-        return trans
-    end
-
-    def nonrootuser
-        Etc.passwd { |user|
-            if user.uid != Process.uid and user.uid > 0
-                return user
-            end
-        }
-    end
-
-    def nonrootgroup
-        Etc.group { |group|
-            if group.gid != Process.gid and group.gid > 0
-                return group
-            end
-        }
-    end
-
-    # If there are any fake data files, retrieve them
-    def fakedata(dir)
-        ary = [$puppetbase, "test"]
-        ary += dir.split("/")
-        dir = File.join(ary)
-
-        unless FileTest.exists?(dir)
-            raise Puppet::DevError, "No fakedata dir %s" % dir
-        end
-        files = Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f|
-            File.join(dir, f)
-        }
-
-        return files
-    end
-
-    def fakefile(name)
-        ary = [$puppetbase, "test"]
-        ary += name.split("/")
-        file = File.join(ary)
-        unless FileTest.exists?(file)
-            raise Puppet::DevError, "No fakedata file %s" % file
-        end
-        return file
-    end
-
-    # wrap how to retrieve the masked mode
-    def filemode(file)
-        File.stat(file).mode & 007777
-    end
-
-    def memory
-        Puppet::Util.memory
-    end
-end
-
-
-module ServerTest
-    include TestPuppet
-    def setup
-        super
-
-        if defined? @@port
-            @@port += 1
-        else
-            @@port = 20000
-        end
-    end
-
-    # create a simple manifest that just creates a file
-    def mktestmanifest
-        file = File.join(Puppet[:confdir], "%ssite.pp" % (self.class.to_s + "test"))
-        #@createdfile = File.join(tmpdir(), self.class.to_s + "manifesttesting" +
-        #    "_" + @method_name)
-        @createdfile = tempfile()
-
-        File.open(file, "w") { |f|
-            f.puts "file { \"%s\": ensure => file, mode => 755 }\n" % @createdfile
-        }
-
-        @@tmpfiles << @createdfile
-        @@tmpfiles << file
-
-        return file
-    end
-
-    # create a server, forked into the background
-    def mkserver(handlers = nil)
-        # our default handlers
-        unless handlers
-            handlers = {
-                :CA => {}, # so that certs autogenerate
-                :Master => {
-                    :Manifest => mktestmanifest(),
-                    :UseNodes => false
-                },
-            }
-        end
-
-        # then create the actual server
-        server = nil
-        assert_nothing_raised {
-            server = Puppet::Server.new(
-                :Port => @@port,
-                :Handlers => handlers
-            )
-        }
-
-        # fork it
-        spid = fork {
-            trap(:INT) { server.shutdown }
-            server.start
-        }
-
-        # and store its pid for killing
-        @@tmppids << spid
-
-        # give the server a chance to do its thing
-        sleep 1 
-        return spid
-    end
-
-end
-
-module ExeTest
-    include ServerTest
-
-    def setup
-        super
-        setbindir
-        setlibdir
-    end
-
-    def bindir
-        File.join($puppetbase, "bin")
-    end
-
-    def setbindir
-        unless ENV["PATH"] =~ /puppet/
-            ENV["PATH"] += ":" + bindir
-        end
-    end
-
-    def setlibdir
-        ENV["RUBYLIB"] = $:.find_all { |dir|
-            dir =~ /puppet/ or dir =~ /\.\./
-        }.join(":")
-    end
-
-    # Run a ruby command.  This explicitly uses ruby to run stuff, since we
-    # don't necessarily know where our ruby binary is, dernit.
-    # Currently unused, because I couldn't get it to work.
-    def rundaemon(*cmd)
-        @ruby ||= %x{which ruby}.chomp
-        cmd = cmd.unshift(@ruby).join(" ")
-
-        out = nil
-        Dir.chdir(bindir()) {
-            out = %x{#{@ruby} #{cmd}}
-        }
-        return out
-    end
-
-    def startmasterd(args = "")
-        output = nil
-
-        manifest = mktestmanifest()
-        args += " --manifest %s" % manifest
-        args += " --confdir %s" % Puppet[:confdir]
-        args += " --vardir %s" % Puppet[:vardir]
-        args += " --masterport %s" % @@port
-        args += " --user %s" % Process.uid
-        args += " --group %s" % Process.gid
-        args += " --nonodes"
-        args += " --autosign true"
-
-        #if Puppet[:debug]
-        #    args += " --debug"
-        #end
-
-        cmd = "puppetmasterd %s" % args
-
-
-        assert_nothing_raised {
-            output = %x{#{cmd}}.chomp
-        }
-        assert_equal("", output, "Puppetmasterd produced output %s" % output)
-        assert($? == 0, "Puppetmasterd exit status was %s" % $?)
-        sleep(1)
-
-        cleanup do
-            stopmasterd
-            sleep(1)
-        end
-
-        return manifest
-    end
-
-    def stopmasterd(running = true)
-        ps = Facter["ps"].value || "ps -ef"
-
-        pidfile = File.join(Puppet[:vardir], "run", "puppetmasterd.pid")
-
-        pid = nil
-        if FileTest.exists?(pidfile)
-            pid = File.read(pidfile).chomp.to_i
-            File.unlink(pidfile)
-        end
-
-        return unless running
-        if running or pid
-            runningpid = nil
-            %x{#{ps}}.chomp.split(/\n/).each { |line|
-                if line =~ /ruby.+puppetmasterd/
-                    next if line =~ /\.rb/ # skip the test script itself
-                    next if line =~ /^puppet/ # skip masters running as 'puppet'
-                    ary = line.sub(/^\s+/, '').split(/\s+/)
-                    pid = ary[1].to_i
-                end
-            }
-
-        end
-
-        # we default to mandating that it's running, but teardown
-        # doesn't require that
-        if pid
-            if pid == $$
-                raise Puppet::Error, "Tried to kill own pid"
-            end
-            begin
-                Process.kill(:INT, pid)
-            rescue
-                # ignore it
-            end
-        end
-    end
-
-    def teardown
-        stopmasterd(false)
-        super
-    end
-end
-
-module FileTesting
-    include TestPuppet
-    def cycle(comp)
-        trans = nil
-        assert_nothing_raised {
-            trans = comp.evaluate
-        }
-        assert_nothing_raised {
-            trans.evaluate
-        }
-    end
-
-    def randlist(list)
-        num = rand(4)
-        if num == 0
-            num = 1
-        end
-        set = []
-
-        ret = []
-        num.times { |index|
-            item = list[rand(list.length)]
-            if set.include?(item)
-                redo
-            end
-
-            ret.push item
-        }
-        return ret
-    end
-
-    def mkranddirsandfiles(dirs = nil,files = nil,depth = 3)
-        if depth < 0
-            return
-        end
-
-        unless dirs
-            dirs = %w{This Is A Set Of Directories}
-        end
-
-        unless files
-            files = %w{and this is a set of files}
-        end
-
-        tfiles = randlist(files)
-        tdirs = randlist(dirs)
-
-        tfiles.each { |file|
-            File.open(file, "w") { |of|
-                4.times {
-                    of.puts rand(100)
-                }
-            }
-        }
-
-        tdirs.each { |dir|
-            # it shouldn't already exist, but...
-            unless FileTest.exists?(dir)
-                Dir.mkdir(dir)
-                FileUtils.cd(dir) {
-                    mkranddirsandfiles(dirs,files,depth - 1)
-                }
-            end
-        }
-    end
-
-    def file_list(dir)
-        list = nil
-        FileUtils.cd(dir) {
-            list = %x{find . 2>/dev/null}.chomp.split(/\n/)
-        }
-        return list
-    end
-
-    def assert_trees_equal(fromdir,todir)
-        assert(FileTest.directory?(fromdir))
-        assert(FileTest.directory?(todir))
-
-        # verify the file list is the same
-        fromlist = nil
-        FileUtils.cd(fromdir) {
-            fromlist = %x{find . 2>/dev/null}.chomp.split(/\n/).reject { |file|
-                ! FileTest.readable?(file)
-            }.sort
-        }
-        tolist = file_list(todir).sort
-
-        fromlist.sort.zip(tolist.sort).each { |a,b|
-            assert_equal(a, b,
-            "Fromfile %s with length %s does not match tofile %s with length %s" %
-                    [a, fromlist.length, b, tolist.length])
-        }
-        #assert_equal(fromlist,tolist)
-
-        # and then do some verification that the files are actually set up
-        # the same
-        checked = 0
-        fromlist.each_with_index { |file,i|
-            fromfile = File.join(fromdir,file)
-            tofile = File.join(todir,file)
-            fromstat = File.stat(fromfile)
-            tostat = File.stat(tofile)
-            [:ftype,:gid,:mode,:uid].each { |method|
-                assert_equal(
-                    fromstat.send(method),
-                    tostat.send(method)
-                )
-
-                next if fromstat.ftype == "directory"
-                if checked < 10 and i % 3 == 0
-                    from = File.open(fromfile) { |f| f.read }
-                    to = File.open(tofile) { |f| f.read }
-
-                    assert_equal(from,to)
-                    checked += 1
-                end
-            }
-        }
-    end
-
-    def random_files(dir)
-        checked = 0
-        list = file_list(dir)
-        list.reverse.each_with_index { |file,i|
-            path = File.join(dir,file)
-            stat = File.stat(dir)
-            if checked < 10 and (i % 3) == 2
-                unless yield path
-                    next
-                end
-                checked += 1
-            end
-        }
-    end
-
-    def delete_random_files(dir)
-        deleted = []
-        random_files(dir) { |file|
-            stat = File.stat(file)
-            begin
-                if stat.ftype == "directory"
-                    false
-                else
-                    deleted << file
-                    File.unlink(file)
-                    true
-                end
-            rescue => detail
-                # we probably won't be able to open our own secured files
-                puts detail
-                false
-            end
-        }
-
-        return deleted
-    end
-
-    def add_random_files(dir)
-        added = []
-        random_files(dir) { |file|
-            stat = File.stat(file)
-            begin
-                if stat.ftype == "directory"
-                    name = File.join(file,"file" + rand(100).to_s)
-                    File.open(name, "w") { |f|
-                        f.puts rand(10)
-                    }
-                    added << name
-                else
-                    false
-                end
-            rescue => detail
-                # we probably won't be able to open our own secured files
-                puts detail
-                false
-            end
-        }
-        return added
-    end
-
-    def modify_random_files(dir)
-        modded = []
-        random_files(dir) { |file|
-            stat = File.stat(file)
-            begin
-                if stat.ftype == "directory"
-                    false
-                else
-                    File.open(file, "w") { |f|
-                        f.puts rand(10)
-                    }
-                    modded << name
-                    true
-                end
-            rescue => detail
-                # we probably won't be able to open our own secured files
-                puts detail
-                false
-            end
-        }
-        return modded
-    end
-
-    def readonly_random_files(dir)
-        modded = []
-        random_files(dir) { |file|
-            stat = File.stat(file)
-            begin
-                if stat.ftype == "directory"
-                    File.new(file).chmod(0111)
-                else
-                    File.new(file).chmod(0000)
-                end
-                modded << file
-            rescue => detail
-                # we probably won't be able to open our own secured files
-                puts detail
-                false
-            end
-        }
-        return modded
-    end
-
-    def conffile
-        File.join($puppetbase,"examples/root/etc/configfile")
-    end
-end
-
-module ParserTesting
-    include TestPuppet
-    AST = Puppet::Parser::AST
-
-    def astarray(*args)
-        AST::ASTArray.new(
-            :children => args
-        )
-    end
-
-    def classobj(name, args = {})
-        args[:type] ||= nameobj(name)
-        args[:code] ||= AST::ASTArray.new(
-            :file => __FILE__,
-            :line => __LINE__,
-            :children => [
-                varobj("%svar" % name, "%svalue" % name),
-                fileobj("/%s" % name)
-            ]
-        )
-        assert_nothing_raised("Could not create class %s" % name) {
-            return AST::ClassDef.new(args)
-        }
-    end
-
-    def tagobj(*names)
-        args = {}
-        newnames = names.collect do |name|
-            if name.is_a? AST
-                name
-            else
-                nameobj(name)
-            end
-        end
-        args[:type] = astarray(*newnames)
-        assert_nothing_raised("Could not create tag %s" % names.inspect) {
-            return AST::Tag.new(args)
-        }
-    end
-
-    def compobj(name, args = {})
-        args[:file] ||= tempfile()
-        args[:line] ||= rand(100)
-        args[:type] ||= nameobj(name)
-        args[:args] ||= AST::ASTArray.new(
-            :file => tempfile(),
-            :line => rand(100),
-            :children => []
-        )
-        args[:code] ||= AST::ASTArray.new(
-            :file => tempfile(),
-            :line => rand(100),
-            :children => [
-                varobj("%svar" % name, "%svalue" % name),
-                fileobj("/%s" % name)
-            ]
-        )
-        assert_nothing_raised("Could not create compdef %s" % name) {
-            return AST::CompDef.new(args)
-        }
-    end
-
-    def objectdef(type, name, params)
-        assert_nothing_raised("Could not create %s %s" % [type, name]) {
-            return AST::ObjectDef.new(
-                :file => __FILE__,
-                :line => __LINE__,
-                :name => stringobj(name),
-                :type => nameobj(type),
-                :params => objectinst(params)
-            )
-        }
-    end
-
-    def fileobj(path, hash = {"owner" => "root"})
-        assert_nothing_raised("Could not create file %s" % path) {
-            return objectdef("file", path, hash)
-#            return AST::ObjectDef.new(
-#                :file => tempfile(),
-#                :line => rand(100),
-#                :name => stringobj(path),
-#                :type => nameobj("file"),
-#                :params => objectinst(hash)
-#            )
-        }
-    end
-
-    def nameobj(name)
-        assert_nothing_raised("Could not create name %s" % name) {
-            return AST::Name.new(
-                :file => tempfile(),
-                :line => rand(100),
-                :value => name
-            )
-        }
-    end
-
-    def typeobj(name)
-        assert_nothing_raised("Could not create type %s" % name) {
-            return AST::Type.new(
-                :file => tempfile(),
-                :line => rand(100),
-                :value => name
-            )
-        }
-    end
-
-    def nodedef(name)
-        assert_nothing_raised("Could not create node %s" % name) {
-            return AST::NodeDef.new(
-                :file => tempfile(),
-                :line => rand(100),
-                :names => nameobj(name),
-                :code => AST::ASTArray.new(
-                    :children => [
-                        varobj("%svar" % name, "%svalue" % name),
-                        fileobj("/%s" % name)
-                    ]
-                )
-            )
-        }
-    end
-
-    def objectinst(hash)
-        assert_nothing_raised("Could not create object instance") {
-            params = hash.collect { |param, value|
-                objectparam(param, value)
-            }
-            return AST::ObjectInst.new(
-                :file => tempfile(),
-                :line => rand(100),
-                :children => params
-            )
-        }
-    end
-
-    def objectparam(param, value)
-        # Allow them to pass non-strings in
-        if value.is_a?(String)
-            value = stringobj(value)
-        end
-        assert_nothing_raised("Could not create param %s" % param) {
-            return AST::ObjectParam.new(
-                :file => tempfile(),
-                :line => rand(100),
-                :param => nameobj(param),
-                :value => value
-            )
-        }
-    end
-
-    def stringobj(value)
-        AST::String.new(
-            :file => tempfile(),
-            :line => rand(100),
-            :value => value
-        )
-    end
-
-    def varobj(name, value)
-        unless value.is_a? AST
-            value = stringobj(value)
-        end
-        assert_nothing_raised("Could not create %s code" % name) {
-            return AST::VarDef.new(
-                :file => tempfile(),
-                :line => rand(100),
-                :name => nameobj(name),
-                :value => value
-            )
-        }
-    end
-
-    def varref(name)
-        assert_nothing_raised("Could not create %s variable" % name) {
-            return AST::Variable.new(
-                :file => __FILE__,
-                :line => __LINE__,
-                :value => name
-            )
-        }
-    end
-
-    def argobj(name, value)
-        assert_nothing_raised("Could not create %s compargument" % name) {
-            return AST::CompArgument.new(
-                :children => [nameobj(name), stringobj(value)]
-            )
-        }
-    end
-
-    def defaultobj(type, params)
-        pary = []
-        params.each { |p,v|
-            pary << AST::ObjectParam.new(
-                :file => __FILE__,
-                :line => __LINE__,
-                :param => nameobj(p),
-                :value => stringobj(v)
-            )
-        }
-        past = AST::ASTArray.new(
-            :file => __FILE__,
-            :line => __LINE__,
-            :children => pary
-        )
-
-        assert_nothing_raised("Could not create defaults for %s" % type) {
-            return AST::TypeDefaults.new(
-                :file => __FILE__,
-                :line => __LINE__,
-                :type => typeobj(type),
-                :params => past
-            )
-        }
-    end
-
-    def taggedobj(name, ftype = :statement)
-        functionobj("tagged", name, ftype)
-    end
-
-    def functionobj(function, name, ftype = :statement)
-        func = nil
-        assert_nothing_raised do
-            func = Puppet::Parser::AST::Function.new(
-                :name => function,
-                :ftype => ftype,
-                :arguments => AST::ASTArray.new(
-                    :children => [nameobj(name)]
-                )
-            )
-        end
-
-        return func
-    end
-
-    # This assumes no nodes
-    def assert_creates(manifest, *files)
-        interp = nil
-        assert_nothing_raised {
-            interp = Puppet::Parser::Interpreter.new(
-                :Manifest => manifest,
-                :UseNodes => false
-            )
-        }
-
-        config = nil
-        assert_nothing_raised {
-            config = interp.run(Facter["hostname"].value, {})
-        }
-
-        comp = nil
-        assert_nothing_raised {
-            comp = config.to_type
-        }
-
-        assert_apply(comp)
-
-        files.each do |file|
-            assert(FileTest.exists?(file), "Did not create %s" % file)
-        end
-    end
-
-    def mk_transobject(file = "/etc/passwd")
-        obj = nil
-        assert_nothing_raised {
-            obj = Puppet::TransObject.new("file", file)
-            obj["owner"] = "root"
-            obj["mode"] = "644"
-        }
-
-        return obj
-    end
-
-    def mk_transbucket(*objects)
-        bucket = nil
-        assert_nothing_raised {
-            bucket = Puppet::TransBucket.new
-            bucket.name = "yayname"
-            bucket.type = "yaytype"
-        }
-
-        objects.each { |o| bucket << o }
-
-        return bucket
-    end
-
-    # Make a tree of objects, yielding if desired
-    def mk_transtree(depth = 4, width = 2)
-        top = nil
-        assert_nothing_raised {
-            top = Puppet::TransBucket.new
-            top.name = "top"
-            top.type = "bucket"
-        }
-
-        bucket = top
-
-        file = tempfile()
-        depth.times do |i|
-            objects = []
-            width.times do |j|
-                path = tempfile + i.to_s
-                obj = Puppet::TransObject.new("file", path)
-                obj["owner"] = "root"
-                obj["mode"] = "644"
-
-                # Yield, if they want
-                if block_given?
-                    yield(obj, i, j)
-                end
-
-                objects << obj
-            end
-
-            newbucket = mk_transbucket(*objects)
-
-            bucket.push newbucket
-            bucket = newbucket
-        end
-
-        return top
-    end
-
-    # Take a list of AST objects, evaluate them, and return the results
-    def assert_evaluate(children)
-        top = nil
-        assert_nothing_raised("Could not create top object") {
-            top = AST::ASTArray.new(
-                :children => children
-            )
-        }
-
-        trans = nil
-        scope = nil
-        assert_nothing_raised {
-            scope = Puppet::Parser::Scope.new()
-            trans = scope.evaluate(:ast => top)
-        }
-
-        return trans
-    end
-end
-
-class PuppetTestSuite
-    attr_accessor :subdir
-
-    def self.basedir
-        unless defined? @basedir
-            @basedir = File.join($puppetbase, "test")
-        end
-        @basedir
-    end
-
-    def self.list
-        Dir.entries(self.basedir).find_all { |file|
-            path = File.join(@basedir, file)
-            # Data is for storing test data
-            FileTest.directory?(path) and file !~ /^\./ and file != "data"
-        }
-    end
-
-    def initialize(name)
-        path = File.join(self.class.basedir, name)
-        if FileTest.directory?(path)
-            # load each of the files
-            Dir.entries(path).collect { |file|
-                File.join(path,file)
-            }.find_all { |file|
-                FileTest.file?(file) and file =~ /\.rb$/
-            }.sort { |a,b|
-                # in the order they were modified, so the last modified files
-                # are loaded and thus displayed last
-                File.stat(b) <=> File.stat(a)
-            }.each { |file|
-                require file
-            }
-        elsif FileTest.file?(path) && path =~ /\.rb$/
-            require path
-        else
-            puts "TestSuites are directories or files containing test cases"
-            puts "no such directory: %s" % path
-            exit(65)
-        end
-    end
-end
-
-# a list of files that we can parse for testing
-def textfiles
-    textdir = File.join($puppetbase,"examples","code", "snippets")
-    Dir.entries(textdir).reject { |f|
-        f =~ /^\./ or f =~ /fail/
-    }.each { |f|
-        yield File.join(textdir, f)
-    }
-end
-
-def failers
-    textdir = File.join($puppetbase,"examples","code", "failers")
-    # only parse this one file now
-    files = Dir.entries(textdir).reject { |file|
-        file =~ %r{\.swp}
-    }.reject { |file|
-        file =~ %r{\.disabled}
-    }.collect { |file|
-        File.join(textdir,file)
-    }.find_all { |file|
-        FileTest.file?(file)
-    }.sort.each { |file|
-        Puppet.debug "Processing %s" % file
-        yield file
-    }
-end
-
-# $Id$
diff --git a/test/lib/support/file.rb b/test/lib/support/file.rb
index f8d1e0c00..2789ad351 100644
--- a/test/lib/support/file.rb
+++ b/test/lib/support/file.rb
@@ -226,3 +226,5 @@ module PuppetTestSupport
         end
     end
 end
+
+# $Id$