puppet 0.18.4 → 0.22.4

data/test/{other → util}/filetype.rb

@@ -1,16 +1,13 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
-require 'puppet/filetype'
+require 'puppet/util/filetype'
 require 'puppettest'
-require 'test/unit'
 
 class TestFileType < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
 
     def test_flat
         obj = nil
@@ -18,7 +15,7 @@ class TestFileType < Test::Unit::TestCase
         type = nil
 
         assert_nothing_raised {
-            type = Puppet::FileType.filetype(:flat)
+            type = Puppet::Util::FileType.filetype(:flat)
         }
 
         assert(type, "Could not retrieve flat filetype")
@@ -62,7 +59,7 @@ class TestFileType < Test::Unit::TestCase
         type = nil
 
         assert_nothing_raised {
-            type = Puppet::FileType.filetype(:netinfo)
+            type = Puppet::Util::FileType.filetype(:netinfo)
         }
 
         assert(type, "Could not retrieve netinfo filetype")
@@ -77,7 +74,7 @@ class TestFileType < Test::Unit::TestCase
 
             array = nil
 
-            assert_nothing_raised {
+            assert_nothing_raised("Failed to parse %s map" % map) {
                 array = obj.to_array
             }
 
@@ -92,4 +89,4 @@ class TestFileType < Test::Unit::TestCase
     end
 end
 
-# $Id: filetype.rb 1068 2006-04-04 23:13:55Z luke $
+# $Id: filetype.rb 2259 2007-03-06 19:03:05Z luke $

data/test/util/graph.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2006-11-16.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppettest/graph'
+require 'puppet/util/graph'
+
+class TestUtilGraph < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::Graph
+    
+	def test_to_graph
+	    children = %w{a b c d}
+        list = Container.new("yay", children)
+        
+        graph = nil
+        assert_nothing_raised do
+            graph = list.to_graph
+        end
+        
+        assert(graph.vertices.include?(list), "wtf?")
+        
+        ([list] + children).each do |thing|
+            assert(graph.vertex?(thing), "%s is not a vertex" % thing)
+        end
+        children.each do |child|
+            assert(graph.edge?(list, child),
+                "%s/%s was not added as an edge" % ["yay", child])
+        end
+    end
+    
+    def test_recursive_to_graph
+        one, two, three, middle, top = build_tree
+        
+        graph = nil
+        assert_nothing_raised do
+            graph = top.to_graph
+        end
+        
+        (%w{a b c d e f g h} + [one, two, middle, top]).each do |v|
+            assert(graph.vertex?(v), "%s is not a vertex" % v)
+        end
+        
+        [one, two, middle, top].each do |con|
+            con.each do |child|
+                assert(graph.edge?(con, child), "%s/%s is not an edge" % [con, child])
+            end
+        end
+        
+        # Now make sure we correctly retrieve the leaves from each container
+        {top => %w{a b c d e f g h i j},
+         one => %w{a b},
+         two => %w{c d},
+         three => %w{i j},
+         middle => %w{c d e f}}.each do |cont, list|
+            leaves = nil
+            assert_nothing_raised do
+                leaves = graph.leaves(cont)
+            end
+            leaves = leaves.sort
+            assert_equal(list.sort, leaves.sort,
+                "Got incorrect leaf list for %s" % cont.name)
+            %w{a b c d e f g h}.each do |letter|
+                unless list.include?(letter)
+                    assert(!leaves.include?(letter),
+                        "incorrectly got %s as a leaf of %s" %
+                            [letter, cont.to_s])
+                end
+            end
+        end
+    end
+    
+    def test_to_graph_with_block
+        middle = Container.new "middle", ["c", "d", 3, 4]
+        top = Container.new "top", ["a", "b", middle, 1, 2]
+        
+        graph = nil
+        assert_nothing_raised() { 
+            graph = top.to_graph { |c| c.is_a?(String) or c.is_a?(Container) }
+        }
+        
+        %w{a b c d}.each do |child|
+            assert(graph.vertex?(child), "%s was not added as a vertex" % child)
+        end
+        
+        [1, 2, 3, 4].each do |child|
+            assert(! graph.vertex?(child), "%s is a vertex" % child)
+        end
+    end
+
+    def test_cyclic_graphs
+        one = Container.new "one", %w{a b}
+        two = Container.new "two", %w{c d}
+        
+        one.push(two)
+        two.push(one)
+        
+        assert_raise(Puppet::Error, "did not fail on cyclic graph") do
+            one.to_graph
+        end
+    end
+end
+
+# $Id: graph.rb 2009 2007-01-01 21:08:45Z luke $

data/test/{other → util}/inifile.rb

@@ -1,20 +1,17 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
-require 'puppet/inifile'
+require 'puppet/util/inifile'
 require 'puppettest'
-require 'test/unit'
 
 class TestFileType < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
 
     def setup
         super
-        @file = Puppet::IniConfig::File.new
+        @file = Puppet::Util::IniConfig::File.new
     end
     
     def teardown
@@ -23,12 +20,12 @@ class TestFileType < Test::Unit::TestCase
     end
 
     def test_simple
-        fname = mkfile("[main]\nkey1=value1\n# Comment\nkey2=value2")
+        fname = mkfile("[main]\nkey1=value1\n# Comment\nkey2=value=2")
         assert_nothing_raised {
             @file.read(fname)
         }
         s = get_section('main')
-        assert_entries(s, { 'key1' => 'value1', 'key2' => 'value2' })
+        assert_entries(s, { 'key1' => 'value1', 'key2' => 'value=2' })
         @file['main']['key2'] = 'newvalue2'
         @file['main']['key3'] = 'newvalue3'
         text = s.format
@@ -83,6 +80,7 @@ class TestFileType < Test::Unit::TestCase
     end
 
     def test_whitespace
+        # FIXME: Should we really accept keys preceded by whitespace ?
         fname = mkfile("[main]\n  key1=v1\nkey2  =v2\n")
         assert_nothing_raised {
             @file.read(fname)
@@ -90,6 +88,21 @@ class TestFileType < Test::Unit::TestCase
         s = get_section('main')
         assert_equal('v1', s['key1'])
         assert_equal('v2', s['key2'])
+        # FIXME: We are losing whitespace around keys
+        assert_equal("[main]\nkey1=v1\nkey2=v2\n", s.format)
+    end
+
+    def test_continuation
+        cont = "[main]\nkey1=v1\nkey2=v2a\n v2b\nkey3=\n\tv3a\n v3b\n"
+        fname = mkfile(cont)
+        assert_nothing_raised {
+            @file.read(fname)
+        }
+        s = get_section('main')
+        assert_equal('v1', s['key1'])
+        assert_equal("v2a\n v2b", s['key2'])
+        assert_equal("\n\tv3a\n v3b", s['key3'])
+        assert_equal(cont, s.format)
     end
 
     def assert_entries(section, hash)

data/test/util/loadedfile.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/util/loadedfile'
+require 'puppettest'
+
+class TestLoadedFile < Test::Unit::TestCase
+	include PuppetTest
+    def test_file
+        Puppet[:filetimeout] = 0
+        file = nil
+        path = tempfile()
+        File.open(path, "w") { |f| f.puts "yayness" }
+        assert_nothing_raised {
+            file = Puppet::Util::LoadedFile.new(path)
+        }
+
+        assert(!file.changed?, "File incorrectly returned changed")
+
+        File.open(path, "w") { |f| f.puts "booness" }
+        #file.tstamp = File.stat(path).ctime - 5
+        new = File.stat(path).ctime - 5
+        file.tstamp = new
+
+        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::Util::LoadedFile.new(path)
+        }
+
+        assert_nothing_raised {
+            assert(!file.changed?,
+                "File thought it changed immediately")
+        }
+
+        sleep 1
+        File.open(path, "w") { |f| f.puts "yay" }
+        #file.tstamp = 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
+
+    def test_stamp
+        file = tempfile()
+        File.open(file, "w") { |f| f.puts "" }
+        obj = nil
+        assert_nothing_raised {
+            obj = Puppet::Util::LoadedFile.new(file)
+        }
+
+        # Make sure we don't refresh
+        Puppet[:filetimeout] = 50
+
+        stamp = File.stat(file).ctime
+
+        assert_equal(stamp, obj.stamp)
+
+        sleep 1
+        # Now change the file, and make sure the stamp doesn't update yet
+        File.open(file, "w") { |f| f.puts "" }
+        assert_equal(stamp, obj.stamp,
+            "File prematurely refreshed")
+
+        Puppet[:filetimeout] = 0
+        assert_equal(File.stat(file).ctime, obj.stamp,
+            "File did not refresh")
+    end
+
+    # Testing #394.
+    def test_changed_missing_file
+        file = tempfile()
+        File.open(file, "w") { |f| f.puts "" }
+        obj = nil
+        assert_nothing_raised {
+            obj = Puppet::Util::LoadedFile.new(file)
+        }
+        Puppet[:filetimeout] = -10
+
+        assert_nothing_raised {
+            obj.changed?
+        }
+
+        # Now remove the file
+        File.unlink(file)
+
+        assert_nothing_raised("removed file threw an error") {
+            assert(obj.changed?, "File was not considered changed when missing")
+        }
+    end
+end
+
+# $Id: loadedfile.rb 2181 2007-02-08 05:11:49Z luke $

data/test/{other → util}/log.rb

@@ -1,37 +1,32 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
-require 'puppet/log'
+require 'puppet/util/log'
 require 'puppettest'
-require 'test/unit'
-
-# $Id: log.rb 1315 2006-06-27 05:15:51Z luke $
 
 class TestLog < Test::Unit::TestCase
-    include TestPuppet
+    include PuppetTest
 
     def setup
         super
-        @oldloglevel = Puppet::Log.level
-        Puppet::Log.close
+        @oldloglevel = Puppet::Util::Log.level
+        Puppet::Util::Log.close
     end
 
     def teardown
         super
-        Puppet::Log.close
-        Puppet::Log.level = @oldloglevel
-        Puppet::Log.newdestination(:console)
+        Puppet::Util::Log.close
+        Puppet::Util::Log.level = @oldloglevel
+        Puppet::Util::Log.newdestination(:console)
     end
 
     def getlevels
         levels = nil
         assert_nothing_raised() {
             levels = []
-            Puppet::Log.eachlevel { |level| levels << level }
+            Puppet::Util::Log.eachlevel { |level| levels << level }
         }
         # Don't test the top levels; too annoying
         return levels.reject { |level| level == :emerg or level == :crit }
@@ -41,7 +36,7 @@ class TestLog < Test::Unit::TestCase
         levels.collect { |level|
             next if level == :alert
             assert_nothing_raised() {
-                Puppet::Log.new(
+                Puppet::Util::Log.new(
                     :level => level,
                     :source => "Test",
                     :message => "Unit test for %s" % level
@@ -53,16 +48,16 @@ class TestLog < Test::Unit::TestCase
     def test_logfile
         fact = nil
         levels = nil
-        Puppet::Log.level = :debug
+        Puppet::Util::Log.level = :debug
         levels = getlevels
         logfile = tempfile()
         fact = nil
         assert_nothing_raised() {
-            Puppet::Log.newdestination(logfile)
+            Puppet::Util::Log.newdestination(logfile)
         }
         msgs = mkmsgs(levels)
         assert(msgs.length == levels.length)
-        Puppet::Log.close
+        Puppet::Util::Log.close
         count = 0
 
         assert(FileTest.exists?(logfile), "Did not create logfile")
@@ -83,27 +78,16 @@ class TestLog < Test::Unit::TestCase
             }
         }
         assert_nothing_raised() {
-            Puppet::Log.newdestination("syslog")
+            Puppet::Util::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
-        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")
+            Puppet::Util::Log.newdestination("/dev/null")
         }
         getlevels.each { |level|
             assert_nothing_raised() {
@@ -113,18 +97,18 @@ class TestLog < Test::Unit::TestCase
     end
 
     def test_output
-        Puppet::Log.level = :notice
-        assert(Puppet.err("This is an error").is_a?(Puppet::Log))
+        Puppet::Util::Log.level = :notice
+        assert(Puppet.err("This is an error").is_a?(Puppet::Util::Log))
         assert(Puppet.debug("This is debugging").nil?)
-        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))
+        Puppet::Util::Log.level = :debug
+        assert(Puppet.err("This is an error").is_a?(Puppet::Util::Log))
+        assert(Puppet.debug("This is debugging").is_a?(Puppet::Util::Log))
     end
 
     def test_creatingdirs
         dir = tempfile()
         file = File.join(dir, "logfile")
-        Puppet::Log.newdestination file
+        Puppet::Util::Log.newdestination file
         Puppet.info "testing logs"
         assert(FileTest.directory?(dir))
         assert(FileTest.file?(file))
@@ -136,31 +120,44 @@ class TestLog < Test::Unit::TestCase
 
         file = Puppet.type(:file).create(
             :path => path,
-            :check => [:owner, :group, :mode, :checksum]
+            :check => [:owner, :group, :mode, :checksum],
+            :ensure => :file
         )
         file.tags = %w{this is a test}
 
+        property = file.property(:ensure)
+        assert(property, "Did not get property")
         log = nil
         assert_nothing_raised {
-            log = Puppet::Log.new(
+            log = Puppet::Util::Log.new(
                 :level => :info,
-                :source => file,
+                :source => property,
                 :message => "A test message"
             )
         }
 
-        assert(log.tags, "Got no tags")
+        # Now yaml and de-yaml it, and test again
+        yamllog = YAML.load(YAML.dump(log))
+
+        {:log => log, :yaml => yamllog}.each do |type, msg|
+            assert(msg.tags, "Got no tags")
+
+            msg.tags.each do |tag|
+                assert(msg.tagged?(tag), "Was not tagged with %s" % tag)
+            end
+
+            assert_equal(msg.tags, property.tags, "Tags were not equal")
+            assert_equal(msg.source, property.path, "Source was not set correctly")
+        end
 
-        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::Log.newdestination :syslog
+        Puppet::Util::Log.newdestination :syslog
 
         assert_nothing_raised {
-            Puppet::Log.new(
+            Puppet::Util::Log.new(
                 :level => :info,
                 :message => "A message with %s in it"
             )
@@ -175,7 +172,7 @@ class TestLog < Test::Unit::TestCase
             :check => %w{owner group}
         )
         assert_nothing_raised {
-            msg = Puppet::Log.new(:level => :info, :message => "This is a message")
+            msg = Puppet::Util::Log.new(:level => :info, :message => "This is a message")
         }
         assert_nothing_raised {
             msg.source = file
@@ -209,7 +206,7 @@ class TestLog < Test::Unit::TestCase
     def test_destination_matching
         dest = nil
         assert_nothing_raised {
-            dest = Puppet::Log.newdesttype("Destine") do
+            dest = Puppet::Util::Log.newdesttype("Destine") do
                 def handle(msg)
                     puts msg
                 end
@@ -224,6 +221,55 @@ class TestLog < Test::Unit::TestCase
             dest.match(:yayness)
         }
         assert(dest.match("Yayness"), "Did not match yayness")
-        Puppet::Log.close(dest)
+        Puppet::Util::Log.close(dest)
+    end
+
+    def test_autoflush
+        file = tempfile
+        Puppet::Util::Log.close(:console)
+        Puppet::Util::Log.newdestination(file)
+        Puppet.warning "A test"
+        assert(File.read(file) !~ /A test/,
+            "File defualted to autoflush")
+        Puppet::Util::Log.flush
+        assert(File.read(file) =~ /A test/,
+            "File did not flush")
+        Puppet::Util::Log.close(file)
+
+        # Now try one with autoflush enabled
+        Puppet[:autoflush] = true
+        file = tempfile
+        Puppet::Util::Log.newdestination(file)
+        Puppet.warning "A test"
+        assert(File.read(file) =~ /A test/,
+            "File did not autoflush")
+        Puppet::Util::Log.close(file)
+    end
+
+    def test_reopen
+        Puppet[:autoflush] = true
+        file = tempfile
+        Puppet::Util::Log.close(:console)
+        Puppet::Util::Log.newdestination(file)
+        Puppet.warning "A test"
+        assert(File.read(file) =~ /A test/,
+            "File did not flush")
+        # Rename the file 
+        newfile = file + ".old"
+        File.rename(file, newfile)
+
+        # Send another log
+        Puppet.warning "Another test"
+        assert(File.read(newfile) =~ /Another test/,
+            "File did not rename")
+
+        # Now reopen the log
+        Puppet::Util::Log.reopen
+        Puppet.warning "Reopen test"
+        assert(File.read(file) =~ /Reopen test/,
+            "File did not reopen")
+        Puppet::Util::Log.close(file)
     end
 end
+
+# $Id: log.rb 2259 2007-03-06 19:03:05Z luke $