Reworking test/lib structure a bit, and renaming all of the files so that their file names match their module names

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

5 files changed, 0 insertions, 847 deletions

diff --git a/test/lib/support/assertions.rb b/test/lib/support/assertions.rb
deleted file mode 100644
index 444b0e4ec..000000000
--- a/test/lib/support/assertions.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-module PuppetTestSupport
-    module Assertions
-
-        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
-
-    end
-end
diff --git a/test/lib/support/file.rb b/test/lib/support/file.rb
deleted file mode 100644
index 2789ad351..000000000
--- a/test/lib/support/file.rb
+++ /dev/null
@@ -1,230 +0,0 @@
-module PuppetTestSupport
-    module File
-        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
-end
-
-# $Id$
diff --git a/test/lib/support/helpers.rb b/test/lib/support/helpers.rb
deleted file mode 100644
index 72dae39d6..000000000
--- a/test/lib/support/helpers.rb
+++ /dev/null
@@ -1,60 +0,0 @@
-module PuppetTestSupport
-    module Helpers
-        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
-
-        def cleanup(&block)
-            @@cleaners << block
-        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
-    end
-end
diff --git a/test/lib/support/parser.rb b/test/lib/support/parser.rb
deleted file mode 100644
index fcad02501..000000000
--- a/test/lib/support/parser.rb
+++ /dev/null
@@ -1,344 +0,0 @@
-module PuppetTestSupport
-    module Parser
-        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
-end
diff --git a/test/lib/support/utils.rb b/test/lib/support/utils.rb
deleted file mode 100644
index 9aea05aff..000000000
--- a/test/lib/support/utils.rb
+++ /dev/null
@@ -1,146 +0,0 @@
-module PuppetTestSupport    
-    module Utils
-        def gcdebug(type)
-            Puppet.warning "%s: %s" % [type, ObjectSpace.each_object(type) { |o| }]
-        end
-
-        #
-        # TODO: I think this method needs to be renamed to something a little more explanatory.
-        #
-
-        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
-
-        # 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
-
-        # TODO: rewrite this to use the 'etc' module.
-
-        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 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
-
-        # 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
-
-        # 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
-
-        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
-    end
-end