puppet 0.16.0 → 0.18.4

data/test/other/log.rb

@@ -4,12 +4,12 @@ if __FILE__ == $0
     $puppetbase = "../.."
 end
 
-require 'puppet/log'
 require 'puppet'
+require 'puppet/log'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: log.rb 1120 2006-04-19 23:38:25Z luke $
+# $Id: log.rb 1315 2006-06-27 05:15:51Z luke $
 
 class TestLog < Test::Unit::TestCase
     include TestPuppet
@@ -17,12 +17,14 @@ class TestLog < Test::Unit::TestCase
     def setup
         super
         @oldloglevel = Puppet::Log.level
+        Puppet::Log.close
     end
 
     def teardown
         super
         Puppet::Log.close
         Puppet::Log.level = @oldloglevel
+        Puppet::Log.newdestination(:console)
     end
 
     def getlevels
@@ -51,10 +53,10 @@ class TestLog < Test::Unit::TestCase
     def test_logfile
         fact = nil
         levels = nil
-        oldlevel = Puppet::Log.level
         Puppet::Log.level = :debug
         levels = getlevels
         logfile = tempfile()
+        fact = nil
         assert_nothing_raised() {
             Puppet::Log.newdestination(logfile)
         }
@@ -62,6 +64,9 @@ class TestLog < Test::Unit::TestCase
         assert(msgs.length == levels.length)
         Puppet::Log.close
         count = 0
+
+        assert(FileTest.exists?(logfile), "Did not create logfile")
+
         assert_nothing_raised() {
             File.open(logfile) { |of|
                 count = of.readlines.length
@@ -108,10 +113,10 @@ class TestLog < Test::Unit::TestCase
     end
 
     def test_output
-        Puppet.debug = false
+        Puppet::Log.level = :notice
         assert(Puppet.err("This is an error").is_a?(Puppet::Log))
         assert(Puppet.debug("This is debugging").nil?)
-        Puppet.debug = true
+        Puppet::Log.level = :debug
         assert(Puppet.err("This is an error").is_a?(Puppet::Log))
         assert(Puppet.debug("This is debugging").is_a?(Puppet::Log))
     end
@@ -200,4 +205,25 @@ class TestLog < Test::Unit::TestCase
             assert_equal(:warning, file[:loglevel])
         }
     end
+
+    def test_destination_matching
+        dest = nil
+        assert_nothing_raised {
+            dest = Puppet::Log.newdesttype("Destine") do
+                def handle(msg)
+                    puts msg
+                end
+            end
+        }
+
+        [:destine, "Destine", "destine"].each do |name|
+            assert(dest.match?(name), "Did not match %s" % name.inspect)
+        end
+
+        assert_nothing_raised {
+            dest.match(:yayness)
+        }
+        assert(dest.match("Yayness"), "Did not match yayness")
+        Puppet::Log.close(dest)
+    end
 end

data/test/other/metrics.rb

@@ -36,21 +36,27 @@ if $haverrd
                 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)
-            }
+            typedata = {}
+            typedata[:total] = rand(totalmax)
+            typedata[:managed] = rand(typedata[:total])
+            typedata[:outofsync] = rand(typedata[:managed])
+            typedata[:changed] = rand(typedata[:outofsync])
+            typedata[:totalchanges] = rand(changemax)
 
             events.each { |event|
                 eventdata[event] = rand(eventmax)
             }
 
-            return [typedata,eventdata]
+            return {:typedata => typedata, :eventdata => eventdata}
+        end
+
+        def rundata(report, time)
+            assert_nothing_raised {
+                gendata.each do |name, data|
+                    report.newmetric(name, data)
+                end
+                report.metrics.each { |n, m| m.store(time) }
+            }
         end
 
         def setup
@@ -59,24 +65,20 @@ if $haverrd
         end
 
         def test_fakedata
-            assert_nothing_raised { Puppet::Metric.init }
+            report = Puppet::Transaction::Report.new
             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 }
+                rundata(report, time)
                 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]) }
+            rundata(report, time)
+
+            report.metrics.each do |n, m| m.graph end
 
             File.open(File.join(Puppet[:rrddir],"index.html"),"w") { |of|
                 of.puts "<html><body>"
-                Puppet::Metric.each { |metric|
+                report.metrics.each { |name, metric|
                     of.puts "<img src=%s.png><br>" % metric.name
                 }
             }
@@ -86,4 +88,4 @@ else
     $stderr.puts "Missing RRD library -- skipping metric tests"
 end
 
-# $Id: metrics.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: metrics.rb 1350 2006-06-30 22:30:27Z luke $

data/test/other/parsedfile.rb

@@ -12,6 +12,7 @@ require 'test/unit'
 class TestParsedFile < Test::Unit::TestCase
 	include TestPuppet
     def test_file
+        Puppet[:filetimeout] = 0
         file = nil
         path = tempfile()
         File.open(path, "w") { |f| f.puts "yayness" }
@@ -21,11 +22,37 @@ class TestParsedFile < Test::Unit::TestCase
 
         assert(!file.changed?, "File incorrectly returned changed")
 
-        sleep(1)
+        #sleep(1)
         File.open(path, "w") { |f| f.puts "booness" }
+        file.send("tstamp=".intern, File.stat(path).ctime - 5)
 
         assert(file.changed?, "File did not catch change")
     end
+
+    def test_timeout
+        Puppet[:filetimeout] = 50
+        path = tempfile()
+
+        File.open(path, "w") { |f| f.puts "yay" }
+        file = nil
+        assert_nothing_raised {
+            file = Puppet::ParsedFile.new(path)
+        }
+
+        assert_nothing_raised { file.changed? }
+
+        File.open(path, "w") { |f| f.puts "yay" }
+        file.send("tstamp=".intern, File.stat(path).ctime - 5)
+
+        assert(!file.changed?,
+            "File was marked as changed too soon")
+
+        Puppet[:filetimeout] = 0
+        assert(file.changed?,
+            "File was not marked as changed soon enough")
+
+
+    end
 end
 
-# $Id: parsedfile.rb 724 2005-10-22 22:27:20Z luke $
+# $Id: parsedfile.rb 1419 2006-07-21 20:11:13Z luke $

data/test/other/puppet.rb

@@ -0,0 +1,79 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/parsedfile'
+require 'puppettest'
+require 'test/unit'
+
+# Test the different features of the main puppet module
+class TestPuppetModule < Test::Unit::TestCase
+	include TestPuppet
+    include SignalObserver
+    
+    def mkfakeclient
+        Class.new(Puppet::Client) do
+            def initialize
+            end
+
+            def runnow
+                Puppet.info "fake client has run"
+            end
+        end
+    end
+
+    def mktestclass
+        Class.new do
+            def initialize(file)
+                @file = file
+            end
+
+            def started?
+                FileTest.exists?(@file)
+            end
+
+            def start
+                File.open(@file, "w") do |f| f.puts "" end
+            end
+
+            def shutdown
+                File.unlink(@file)
+            end
+        end
+    end
+
+    # Make sure that services get correctly started and stopped
+    def test_servicehandling
+        file = tempfile()
+        testclass = mktestclass()
+
+        obj = testclass.new(file)
+
+        assert_nothing_raised {
+            Puppet.newservice(obj)
+        }
+
+        assert_nothing_raised {
+            Puppet.start(false)
+        }
+
+        # Give it a sec or so
+        sleep 0.3
+
+        assert(obj.started?, "Object was not started")
+
+        assert_nothing_raised {
+            Puppet.shutdown(false)
+        }
+        # Give it a sec or so
+        sleep 0.3
+
+        assert(!obj.started?, "Object is still running")
+
+    end
+end
+
+# $Id: puppet.rb 1315 2006-06-27 05:15:51Z luke $

data/test/other/report.rb

@@ -0,0 +1,106 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/transaction/report'
+require 'puppettest'
+require 'test/unit'
+
+class TestReports < Test::Unit::TestCase
+	include TestPuppet
+
+    # Make sure we can use reports as log destinations.
+    def test_reports_as_log_destinations
+        report = nil
+        assert_nothing_raised {
+            report = Puppet::Transaction::Report.new
+        }
+
+        assert_nothing_raised {
+            Puppet::Log.newdestination(report)
+        }
+
+        # Now make a file for testing logging
+        file = Puppet::Type.newfile(:path => tempfile(), :ensure => "file")
+
+        log = nil
+        assert_nothing_raised {
+            log = file.log "This is a message, yo"
+        }
+
+        assert(report.logs.include?(log), "Report did not get log message")
+
+        log = Puppet.info "This is a non-sourced message"
+
+        assert(! report.logs.include?(log), "Report got log message")
+
+        assert_nothing_raised {
+            Puppet::Log.close(report)
+        }
+
+        log = file.log "This is another message, yo"
+
+        assert(! report.logs.include?(log), "Report got log message after close")
+    end
+
+    def test_newmetric
+        report = nil
+        assert_nothing_raised {
+            report = Puppet::Transaction::Report.new
+        }
+
+        assert_nothing_raised {
+            report.newmetric(:mymetric,
+                :total => 12,
+                :done => 6
+            )
+        }
+    end
+
+    if Puppet::Metric.haverrd?
+    def test_rrdgraph_report
+        Puppet.config.use(:metrics)
+        # First do some work
+        objects = []
+        25.times do |i|
+            file = tempfile()
+
+            # Make every third file
+            File.open(file, "w") { |f| f.puts "" } if i % 3 == 0
+
+            objects << Puppet::Type.newfile(
+                :path => file,
+                :ensure => "file"
+            )
+        end
+
+        comp = newcomp(*objects)
+
+        trans = nil
+        assert_nothing_raised("Failed to create transaction") {
+            trans = comp.evaluate
+        }
+
+        assert_nothing_raised("Failed to evaluate transaction") {
+            trans.evaluate
+        }
+
+        method = Puppet::Server::Report.report("rrdgraph")
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::Server::Report.new()
+        }
+
+        assert_nothing_raised {
+            server.report_rrdgraph(trans.report)
+        }
+    end
+    else
+    $stderr.puts "Install RRD for metric reporting tests"
+    end
+end
+
+# $Id: report.rb 1359 2006-07-04 16:27:35Z luke $

data/test/other/storage.rb

@@ -8,7 +8,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-class TestParsedFile < Test::Unit::TestCase
+class TestStorage < Test::Unit::TestCase
 	include TestPuppet
 
     def mkfile
@@ -97,4 +97,4 @@ class TestParsedFile < Test::Unit::TestCase
     end
 end
 
-# $Id: storage.rb 847 2006-01-23 22:38:39Z luke $
+# $Id: storage.rb 1349 2006-06-30 20:46:07Z luke $

data/test/other/transactions.rb

@@ -8,10 +8,60 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: transactions.rb 1113 2006-04-17 16:15:33Z luke $
+# $Id: transactions.rb 1358 2006-07-04 16:07:47Z luke $
 
 class TestTransactions < Test::Unit::TestCase
 	include FileTesting
+
+    # In case they're not in more than one group
+    def test_nothing
+    end
+
+    def test_reports
+        path1 = tempfile()
+        path2 = tempfile()
+        objects = []
+        objects << Puppet::Type.newfile(
+            :path => path1,
+            :content => "yayness"
+        )
+        objects << Puppet::Type.newfile(
+            :path => path2,
+            :content => "booness"
+        )
+
+        trans = assert_events([:file_created, :file_created], *objects)
+
+        report = nil
+
+        assert_nothing_raised {
+            report = trans.report
+        }
+
+        # First test the report logs
+        assert(report.logs.length > 0, "Did not get any report logs")
+
+        report.logs.each do |obj|
+            assert_instance_of(Puppet::Log, obj)
+        end
+
+        # Then test the metrics
+        metrics = report.metrics
+
+        assert(metrics, "Did not get any metrics")
+        assert(metrics.length > 0, "Did not get any metrics")
+
+        assert(metrics.has_key?("objects"), "Did not get object metrics")
+        assert(metrics.has_key?("changes"), "Did not get change metrics")
+
+        metrics.each do |name, metric|
+            assert_instance_of(Puppet::Metric, metric)
+        end
+    end
+
+    unless %x{groups}.chomp.split(/ /).length > 1
+        $stderr.puts "You must be a member of more than one group to test transactions"
+    else
     def ingroup(gid)
         require 'etc'
         begin
@@ -182,7 +232,7 @@ class TestTransactions < Test::Unit::TestCase
             file[:mode] = "755"
         }
 
-        trans = assert_events( [:file_changed], component)
+        trans = assert_events([:file_changed], component)
 
         assert(FileTest.exists?(execfile), "Execfile does not exist")
         File.unlink(execfile)
@@ -277,4 +327,80 @@ class TestTransactions < Test::Unit::TestCase
         assert(FileTest.exists?(path), "File did not get created")
         assert(FileTest.exists?(newfile), "Refresh file did not get created")
     end
+
+    # Make sure that unscheduled and untagged objects still respond to events
+    def test_unscheduledanduntaggedresponse
+        Puppet::Type.type(:schedule).mkdefaultschedules
+        Puppet[:ignoreschedules] = false
+        file = Puppet.type(:file).create(
+            :name => tempfile(),
+            :ensure => "file"
+        )
+
+        fname = tempfile()
+        exec = Puppet.type(:exec).create(
+            :name => "touch %s" % fname,
+            :path => "/usr/bin:/bin",
+            :schedule => "monthly",
+            :subscribe => ["file", file.name]
+        )
+
+        comp = newcomp(file,exec)
+        comp.finalize
+
+        # Run it once
+        assert_apply(comp)
+        assert(FileTest.exists?(fname), "File did not get created")
+
+        assert(!exec.scheduled?, "Exec is somehow scheduled")
+
+        # Now remove it, so it can get created again
+        File.unlink(fname)
+
+        file[:content] = "some content"
+
+        assert_events([:file_changed], comp)
+        assert(FileTest.exists?(fname), "File did not get recreated")
+
+        # Now remove it, so it can get created again
+        File.unlink(fname)
+
+        # And tag our exec
+        exec.tag("testrun")
+
+        # And our file, so it runs
+        file.tag("norun")
+
+        Puppet[:tags] = "norun"
+
+        file[:content] = "totally different content"
+
+        assert(! file.insync?, "Uh, file is in sync?")
+
+        assert_events([:file_changed], comp)
+        assert(FileTest.exists?(fname), "File did not get recreated")
+    end
+
+    def test_failed_reqs_mean_no_run
+        exec = Puppet::Type.type(:exec).create(
+            :command => "/bin/mkdir /this/path/cannot/possibly/exit",
+            :name => "mkdir"
+        )
+
+        file = Puppet::Type.type(:file).create(
+            :path => tempfile(),
+            :require => ["exec", "mkdir"],
+            :ensure => :file
+        )
+
+        comp = newcomp(exec, file)
+
+        comp.finalize
+
+        assert_apply(comp)
+
+        assert(! FileTest.exists?(file[:path]),
+            "File got created even tho its dependency failed")
+    end
+    end
 end