puppet 0.9.2

data/test/other/log.rb

@@ -0,0 +1,195 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet/log'
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+# $Id: log.rb 740 2005-11-01 20:22:19Z luke $
+
+class TestLog < Test::Unit::TestCase
+    include TestPuppet
+
+    def teardown
+        super
+        Puppet::Log.close
+    end
+
+    def getlevels
+        levels = nil
+        assert_nothing_raised() {
+            levels = []
+            Puppet::Log.eachlevel { |level| levels << level }
+        }
+        # Don't test the top levels; too annoying
+        return levels.reject { |level| level == :emerg or level == :crit }
+    end
+
+    def mkmsgs(levels)
+        levels.collect { |level|
+            assert_nothing_raised() {
+                Puppet::Log.new(
+                    :level => level,
+                    :source => "Test",
+                    :message => "Unit test for %s" % level
+                )
+            }
+        }
+    end
+
+    def test_logfile
+        fact = nil
+        levels = nil
+        levels = getlevels
+        logfile = tempfile()
+        assert_nothing_raised() {
+            Puppet::Log.newdestination(logfile)
+        }
+        msgs = mkmsgs(levels)
+        assert(msgs.length == levels.length)
+        Puppet::Log.close
+        count = 0
+        assert_nothing_raised() {
+            File.open(logfile) { |of|
+                count = of.readlines.length
+            }
+        }
+        assert(count == levels.length)
+    end
+
+    def test_syslog
+        levels = nil
+        assert_nothing_raised() {
+            levels = getlevels.reject { |level|
+                level == :emerg || level == :crit
+            }
+        }
+        assert_nothing_raised() {
+            Puppet::Log.newdestination("syslog")
+        }
+        # there's really no way to verify that we got syslog messages...
+        msgs = mkmsgs(levels)
+        assert(msgs.length == levels.length)
+    end
+
+    def test_consolelog
+        Puppet[:debug] = true if __FILE__ == $0
+        fact = nil
+        levels = getlevels
+        assert_nothing_raised() {
+            Puppet::Log.newdestination(:console)
+        }
+        msgs = mkmsgs(levels)
+        assert(msgs.length == levels.length)
+        Puppet::Log.close
+    end
+
+    def test_levelmethods
+        assert_nothing_raised() {
+            Puppet::Log.newdestination("/dev/null")
+        }
+        getlevels.each { |level|
+            assert_nothing_raised() {
+                Puppet.send(level,"Testing for %s" % level)
+            }
+        }
+    end
+
+    def test_output
+        Puppet[:debug] = false
+        assert(Puppet.err("This is an error").is_a?(Puppet::Log))
+        assert(Puppet.debug("This is debugging").nil?)
+        Puppet[:debug] = true
+        assert(Puppet.err("This is an error").is_a?(Puppet::Log))
+        assert(Puppet.debug("This is debugging").is_a?(Puppet::Log))
+    end
+
+    def test_creatingdirs
+        Puppet[:logdest] = "/tmp/logtesting/logfile"
+        Puppet.info "testing logs"
+        assert(FileTest.directory?("/tmp/logtesting"))
+        assert(FileTest.file?("/tmp/logtesting/logfile"))
+
+        system("rm -rf /tmp/logtesting")
+    end
+
+    def test_logtags
+        path = tempfile
+        File.open(path, "w") { |f| f.puts "yayness" }
+
+        file = Puppet::Type::PFile.create(
+            :path => path,
+            :check => [:owner, :group, :mode, :checksum]
+        )
+        file.tags = %w{this is a test}
+
+        log = nil
+        assert_nothing_raised {
+            log = Puppet::Log.new(
+                :level => :info,
+                :source => file,
+                :message => "A test message"
+            )
+        }
+
+        assert(log.tags, "Got no tags")
+
+        assert_equal(log.tags, file.tags, "Tags were not equal")
+        assert_equal(log.source, file.path, "Source was not set correctly")
+    end
+
+    # Verify that we can pass strings that match printf args
+    def test_percentlogs
+        Puppet[:logdest] = :syslog
+
+        assert_nothing_raised {
+            Puppet::Log.new(
+                :level => :info,
+                :message => "A message with %s in it"
+            )
+        }
+    end
+
+    # Verify that the error and source are always strings
+    def test_argsAreStrings
+        msg = nil
+        file = Puppet::Type::PFile.create(
+            :path => tempfile(),
+            :check => %w{owner group}
+        )
+        assert_nothing_raised {
+            msg = Puppet::Log.new(:level => :info, :message => "This is a message")
+        }
+        assert_nothing_raised {
+            msg.source = file
+        }
+
+        assert_instance_of(String, msg.to_s)
+        assert_instance_of(String, msg.source)
+    end
+
+    # Verify that loglevel behaves as one expects
+    def test_loglevel
+        path = tempfile()
+        file = Puppet::Type::PFile.create(
+            :path => path,
+            :create => true
+        )
+
+        assert_nothing_raised {
+            assert_equal(:notice, file[:loglevel])
+        }
+
+        assert_nothing_raised {
+            file[:loglevel] = "warning"
+        }
+
+        assert_nothing_raised {
+            assert_equal(:warning, file[:loglevel])
+        }
+    end
+end

data/test/other/metrics.rb

@@ -0,0 +1,92 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet/metric'
+require 'puppet'
+require 'puppet/type'
+require 'test/unit'
+
+$haverrd = true
+begin
+    require 'RRD'
+rescue LoadError
+    $haverrd = false
+end
+
+if $haverrd
+    class TestMetric < Test::Unit::TestCase
+
+        def gendata
+            totalmax = 1000
+            changemax = 1000
+            eventmax = 10
+            maxdiff = 10
+
+            types = [Puppet::Type::PFile, Puppet::Type::Package, Puppet::Type::Service]
+            data = [:total, :managed, :outofsync, :changed, :totalchanges]
+            events = [:file_changed, :package_installed, :service_started]
+
+            # if this is the first set of data points...
+            typedata = Hash.new { |typehash,type|
+                typehash[type] = Hash.new(0)
+            }
+            eventdata = Hash.new(0)
+            types.each { |type|
+                name = type.name
+                typedata[type] = {}
+                typedata[type][:total] = rand(totalmax)
+                typedata[type][:managed] = rand(typedata[type][:total])
+                typedata[type][:outofsync] = rand(typedata[type][:managed])
+                typedata[type][:changed] = rand(typedata[type][:outofsync])
+                typedata[type][:totalchanges] = rand(changemax)
+            }
+
+            events.each { |event|
+                eventdata[event] = rand(eventmax)
+            }
+
+            return [typedata,eventdata]
+        end
+
+        def setup
+            Puppet[:rrddir] = File.join(Puppet[:puppetvar], "rrdtesting")
+            Puppet[:rrdgraph] = true
+            Puppet[:loglevel] = :debug if __FILE__ == $0
+        end
+
+        def teardown
+            system("rm -rf %s" % Puppet[:rrddir])
+        end
+
+        def test_fakedata
+            assert_nothing_raised { Puppet::Metric.init }
+            time = Time.now.to_i
+            start = time
+            10.times {
+                assert_nothing_raised { Puppet::Metric.load(gendata) }
+                assert_nothing_raised { Puppet::Metric.tally }
+                assert_nothing_raised { Puppet::Metric.store(time) }
+                assert_nothing_raised { Puppet::Metric.clear }
+                time += 300
+            }
+            assert_nothing_raised { Puppet::Metric.load(gendata) }
+            assert_nothing_raised { Puppet::Metric.tally }
+            assert_nothing_raised { Puppet::Metric.store(time) }
+            assert_nothing_raised { Puppet::Metric.graph([start,time]) }
+
+            File.open(File.join(Puppet[:rrddir],"index.html"),"w") { |of|
+                of.puts "<html><body>"
+                Puppet::Metric.each { |metric|
+                    of.puts "<img src=%s.png><br>" % metric.name
+                }
+            }
+        end
+    end
+else
+    $stderr.puts "Missing RRD library -- skipping metric tests"
+end
+
+# $Id: metrics.rb 724 2005-10-22 22:27:20Z luke $

data/test/other/overrides.rb

@@ -0,0 +1,115 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+class TestOverrides < Test::Unit::TestCase
+	include TestPuppet
+    def mksubdirs(basedir, level)
+        @@tmpfiles << basedir
+        dir = basedir.dup
+
+        (level + 1).times { |index|
+            Dir.mkdir(dir)
+            path = File.join(dir, "file")
+            File.open(path, "w") { |f| f.puts "yayness" }
+            dir = File.join(dir, index.to_s)
+        }
+    end
+
+    def test_simpleoverride
+        basedir = File.join(tmpdir(), "overridetesting")
+        mksubdirs(basedir, 1)
+
+        baseobj = nil
+        basefile = File.join(basedir, "file")
+        assert_nothing_raised("Could not create base obj") {
+            baseobj = Puppet::Type::PFile.create(
+                :path => basedir,
+                :recurse => true,
+                :mode => "755"
+            )
+        }
+
+        subobj = nil
+        subdir = File.join(basedir, "0")
+        subfile = File.join(subdir, "file")
+        assert_nothing_raised("Could not create sub obj") {
+            subobj = Puppet::Type::PFile.create(
+                :path => subdir,
+                :recurse => true,
+                :mode => "644"
+            )
+        }
+
+        comp = newcomp("overrides", baseobj, subobj)
+        assert_nothing_raised("Could not eval component") {
+            trans = comp.evaluate
+            trans.evaluate
+        }
+
+        assert(File.stat(basefile).mode & 007777 == 0755)
+        assert(File.stat(subfile).mode & 007777 == 0644)
+    end
+
+    def test_zdeepoverride
+        basedir = File.join(tmpdir(), "deepoverridetesting")
+        mksubdirs(basedir, 10)
+
+        baseobj = nil
+        assert_nothing_raised("Could not create base obj") {
+            baseobj = Puppet::Type::PFile.create(
+                :path => basedir,
+                :recurse => true,
+                :mode => "755"
+            )
+        }
+
+        children = []
+        files = {}
+        subdir = basedir.dup
+        mode = nil
+        10.times { |index|
+            next unless index % 3
+            subdir = File.join(subdir, index.to_s)
+            path = File.join(subdir, "file")
+            if index % 2
+                mode = "644"
+                files[path] = 0644
+            else
+                mode = "750"
+                files[path] = 0750
+            end
+
+            assert_nothing_raised("Could not create sub obj") {
+                children << Puppet::Type::PFile.create(
+                    :path => subdir,
+                    :recurse => true,
+                    :mode => mode
+                )
+            }
+        }
+
+        comp = newcomp("overrides", baseobj)
+        children.each { |child| comp.push child }
+
+        assert_nothing_raised("Could not eval component") {
+            trans = comp.evaluate
+            trans.evaluate
+        }
+
+        files.each { |path, mode|
+            assert(FileTest.exists?(path), "File %s does not exist" % path)
+            curmode = File.stat(path).mode & 007777
+            assert(curmode == mode,
+                "File %s was incorrect mode %o instead of %o" % [path, curmode, mode])
+        }
+    end
+end
+
+# $Id: overrides.rb 724 2005-10-22 22:27:20Z luke $

data/test/other/parsedfile.rb

@@ -0,0 +1,31 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/parsedfile'
+require 'puppettest'
+require 'test/unit'
+
+class TestParsedFile < Test::Unit::TestCase
+	include TestPuppet
+    def test_file
+        file = nil
+        path = tempfile()
+        File.open(path, "w") { |f| f.puts "yayness" }
+        assert_nothing_raised {
+            file = Puppet::ParsedFile.new(path)
+        }
+
+        assert(!file.changed?, "File incorrectly returned changed")
+
+        sleep(1)
+        File.open(path, "w") { |f| f.puts "booness" }
+
+        assert(file.changed?, "File did not catch change")
+    end
+end
+
+# $Id: parsedfile.rb 724 2005-10-22 22:27:20Z luke $

data/test/other/relationships.rb

@@ -0,0 +1,113 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+class TestRelationships < Test::Unit::TestCase
+	include TestPuppet
+    def newfile
+        assert_nothing_raised() {
+            return Puppet::Type::PFile.create(
+                :path => tempfile,
+                :check => [:mode, :owner, :group]
+            )
+        }
+    end
+
+    def test_simplerel
+        file1 = newfile()
+        file2 = newfile()
+        assert_nothing_raised {
+            file1[:require] = [file2.class.name, file2.name]
+        }
+
+        deps = []
+        assert_nothing_raised {
+            file1.eachdependency { |obj|
+                deps << obj
+            }
+        }
+
+        assert_equal(1, deps.length, "Did not get dependency")
+
+        assert_nothing_raised {
+            file1.unsubscribe(file2)
+        }
+
+        deps = []
+        assert_nothing_raised {
+            file1.eachdependency { |obj|
+                deps << obj
+            }
+        }
+
+        assert_equal(0, deps.length, "Still have dependency")
+    end
+
+    def test_newsub
+        file1 = newfile()
+        file2 = newfile()
+
+        sub = nil
+        assert_nothing_raised("Could not create subscription") {
+            sub = Puppet::Event::Subscription.new(
+                :source => file1,
+                :target => file2,
+                :event => :ALL_EVENTS,
+                :callback => :refresh
+            )
+        }
+
+        subs = nil
+
+        assert_nothing_raised {
+            subs = Puppet::Event::Subscription.subscribers(file1)
+        }
+        assert_equal(1, subs.length, "Got incorrect number of subs")
+        assert_equal(sub.target, subs[0], "Got incorrect sub")
+
+        deps = nil
+        assert_nothing_raised {
+            deps = Puppet::Event::Subscription.dependencies(file2)
+        }
+        assert_equal(1, deps.length, "Got incorrect number of deps")
+        assert_equal(sub, deps[0], "Got incorrect dep")
+    end
+
+    def test_eventmatch
+        file1 = newfile()
+        file2 = newfile()
+
+        sub = nil
+        assert_nothing_raised("Could not create subscription") {
+            sub = Puppet::Event::Subscription.new(
+                :source => file1,
+                :target => file2,
+                :event => :ALL_EVENTS,
+                :callback => :refresh
+            )
+        }
+
+        assert(sub.match?(:anything), "ALL_EVENTS did not match")
+        assert(! sub.match?(:NONE), "ALL_EVENTS matched :NONE")
+
+        sub.event = :file_created
+
+        assert(sub.match?(:file_created), "event did not match")
+        assert(sub.match?(:ALL_EVENTS), "ALL_EVENTS did not match")
+        assert(! sub.match?(:NONE), "ALL_EVENTS matched :NONE")
+
+        sub.event = :NONE
+
+        assert(! sub.match?(:file_created), "Invalid match")
+        assert(! sub.match?(:ALL_EVENTS), "ALL_EVENTS matched")
+        assert(! sub.match?(:NONE), "matched :NONE")
+    end
+end
+
+# $Id: relationships.rb 724 2005-10-22 22:27:20Z luke $