puppet 0.25.5 → 2.6.0

data/test/util/inifile.rb

@@ -7,121 +7,132 @@ require 'puppet/util/inifile'
 require 'puppettest'
 
 class TestFileType < Test::Unit::TestCase
-    include PuppetTest
+  include PuppetTest
 
-    def setup
-        super
-        @file = Puppet::Util::IniConfig::File.new
-    end
+  def setup
+    super
+    @file = Puppet::Util::IniConfig::File.new
+  end
 
-    def teardown
-        @file = nil
-        super
-    end
+  def teardown
+    @file = nil
+    super
+  end
 
-    def test_simple
-        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' => 'value=2' })
-        @file['main']['key2'] = 'newvalue2'
-        @file['main']['key3'] = 'newvalue3'
-        text = s.format
-        assert_equal("[main]\nkey1=value1\n# Comment\nkey2=newvalue2\nkey3=newvalue3\n",
-                     s.format)
-    end
+  def test_simple
+    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' => 'value=2' })
+    @file['main']['key2'] = 'newvalue2'
+    @file['main']['key3'] = 'newvalue3'
+    text = s.format
 
-    def test_multi
-        fmain = mkfile("[main]\nkey1=main.value1\n# Comment\nkey2=main.value2")
-        fsub = mkfile("[sub1]\nkey1=sub1 value1\n\n" +
-                        "[sub2]\nkey1=sub2.value1")
-        main_mtime = File::stat(fmain).mtime
-        assert_nothing_raised {
-            @file.read(fmain)
-            @file.read(fsub)
-        }
-        main = get_section('main')
-        assert_entries(main,
-                       { 'key1' => 'main.value1', 'key2' => 'main.value2' })
-        sub1 = get_section('sub1')
-        assert_entries(sub1, { 'key1' => 'sub1 value1' })
-        sub2 = get_section('sub2')
-        assert_entries(sub2, { 'key1' => 'sub2.value1' })
-        [main, sub1, sub2].each { |s| assert( !s.dirty? ) }
-        sub1['key1'] = 'sub1 newvalue1'
-        sub2['key2'] = 'sub2 newvalue2'
-        assert(! main.dirty?)
-        [sub1, sub2].each { |s| assert( s.dirty? ) }
-        @file.store
-        [main, sub1, sub2].each { |s| assert( !s.dirty? ) }
-        assert( File.exists?(fmain) )
-        assert( File.exists?(fsub) )
-        assert_equal(main_mtime, File::stat(fmain).mtime)
-        subtext = File.read(fsub)
-        assert_equal("[sub1]\nkey1=sub1 newvalue1\n\n" +
-                     "[sub2]\nkey1=sub2.value1\nkey2=sub2 newvalue2\n",
-                     subtext)
-    end
+      assert_equal(
+        "[main]\nkey1=value1\n# Comment\nkey2=newvalue2\nkey3=newvalue3\n",
 
-    def test_format_nil
-        fname = mkfile("[main]\nkey1=value1\n# Comment\nkey2=value2\n" +
-                       "# Comment2\n")
-        assert_nothing_raised {
-            @file.read(fname)
-        }
-        s = get_section('main')
-        s['key2'] = nil
-        s['key3'] = nil
-        text = s.format
-        assert_equal("[main]\nkey1=value1\n# Comment\n# Comment2\n",
-                     s.format)
-    end
+          s.format)
+  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)
-        }
-        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_multi
+    fmain = mkfile("[main]\nkey1=main.value1\n# Comment\nkey2=main.value2")
+    fsub = mkfile("[sub1]\nkey1=sub1 value1\n\n[sub2]\nkey1=sub2.value1")
+    main_mtime = File::stat(fmain).mtime
+    assert_nothing_raised {
+      @file.read(fmain)
+      @file.read(fsub)
+    }
+    main = get_section('main')
 
-    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
+      assert_entries(
+        main,
 
-    def assert_entries(section, hash)
-        hash.each do |k, v|
-            assert_equal(v, section[k],
-                        "Expected <#{v}> for #{section.name}[#{k}] " +
-                         "but got <#{section[k]}>")
-        end
-    end
+          { 'key1' => 'main.value1', 'key2' => 'main.value2' })
+    sub1 = get_section('sub1')
+    assert_entries(sub1, { 'key1' => 'sub1 value1' })
+    sub2 = get_section('sub2')
+    assert_entries(sub2, { 'key1' => 'sub2.value1' })
+    [main, sub1, sub2].each { |s| assert( !s.dirty? ) }
+    sub1['key1'] = 'sub1 newvalue1'
+    sub2['key2'] = 'sub2 newvalue2'
+    assert(! main.dirty?)
+    [sub1, sub2].each { |s| assert( s.dirty? ) }
+    @file.store
+    [main, sub1, sub2].each { |s| assert( !s.dirty? ) }
+    assert( File.exists?(fmain) )
+    assert( File.exists?(fsub) )
+    assert_equal(main_mtime, File::stat(fmain).mtime)
+    subtext = File.read(fsub)
 
-    def get_section(name)
-        result = @file[name]
-        assert_not_nil(result)
-        return result
-    end
+      assert_equal(
+        "[sub1]\nkey1=sub1 newvalue1\n\n[sub2]\nkey1=sub2.value1\nkey2=sub2 newvalue2\n",
+
+          subtext)
+  end
 
-    def mkfile(content)
-        file = tempfile()
-        File.open(file, "w") { |f| f.print(content) }
-        return file
+  def test_format_nil
+    fname = mkfile("[main]\nkey1=value1\n# Comment\nkey2=value2\n# Comment2\n")
+    assert_nothing_raised {
+      @file.read(fname)
+    }
+    s = get_section('main')
+    s['key2'] = nil
+    s['key3'] = nil
+    text = s.format
+
+      assert_equal(
+        "[main]\nkey1=value1\n# Comment\n# Comment2\n",
+
+          s.format)
+  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)
+    }
+    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)
+    hash.each do |k, v|
+
+      assert_equal(
+        v, section[k],
+
+          "Expected <#{v}> for #{section.name}[#{k}] but got <#{section[k]}>")
     end
+  end
+
+  def get_section(name)
+    result = @file[name]
+    assert_not_nil(result)
+    result
+  end
+
+  def mkfile(content)
+    file = tempfile
+    File.open(file, "w") { |f| f.print(content) }
+    file
+  end
 end

data/test/util/instance_loader.rb

@@ -7,46 +7,46 @@ require 'puppet/util/instance_loader'
 require 'puppettest'
 
 class TestInstanceloader < Test::Unit::TestCase
-    include PuppetTest
+  include PuppetTest
 
-    def setup
-        super
-        @loader = Class.new do
-            extend Puppet::Util::InstanceLoader
+  def setup
+    super
+    @loader = Class.new do
+      extend Puppet::Util::InstanceLoader
 
-            def self.newstuff(name, value)
-                instance_hash(:stuff)[name] = value
-            end
-        end
+      def self.newstuff(name, value)
+        instance_hash(:stuff)[name] = value
+      end
+    end
 
-        assert_nothing_raised("Could not create instance loader") do
-            @loader.instance_load(:stuff, "puppet/stuff")
-        end
+    assert_nothing_raised("Could not create instance loader") do
+      @loader.instance_load(:stuff, "puppet/stuff")
     end
+  end
 
-    # Make sure we correctly create our autoload instance.  This covers the basics.
-    def test_autoload
-        # Make sure we can retrieve the loader
-        assert_instance_of(Puppet::Util::Autoload, @loader.instance_loader(:stuff), "Could not get instance loader")
+  # Make sure we correctly create our autoload instance.  This covers the basics.
+  def test_autoload
+    # Make sure we can retrieve the loader
+    assert_instance_of(Puppet::Util::Autoload, @loader.instance_loader(:stuff), "Could not get instance loader")
 
-        # Make sure we can get the instance hash
-        assert(@loader.instance_hash(:stuff), "Could not get instance hash")
+    # Make sure we can get the instance hash
+    assert(@loader.instance_hash(:stuff), "Could not get instance hash")
 
-        # Make sure it defines the instance retrieval method
-        assert(@loader.respond_to?(:stuff), "Did not define instance retrieval method")
-    end
+    # Make sure it defines the instance retrieval method
+    assert(@loader.respond_to?(:stuff), "Did not define instance retrieval method")
+  end
 
-    def test_loaded_instances
-        assert_equal([], @loader.loaded_instances(:stuff), "Incorrect loaded instances")
+  def test_loaded_instances
+    assert_equal([], @loader.loaded_instances(:stuff), "Incorrect loaded instances")
 
-        @loader.newstuff(:testing, "a value")
+    @loader.newstuff(:testing, "a value")
 
-        assert_equal([:testing], @loader.loaded_instances(:stuff), "Incorrect loaded instances")
+    assert_equal([:testing], @loader.loaded_instances(:stuff), "Incorrect loaded instances")
 
-        assert_equal("a value", @loader.loaded_instance(:stuff, :testing), "Got incorrect loaded instance")
-    end
+    assert_equal("a value", @loader.loaded_instance(:stuff, :testing), "Got incorrect loaded instance")
+  end
 
-    def test_instance_loading
-    end
+  def test_instance_loading
+  end
 end
 

data/test/util/log.rb

@@ -7,209 +7,213 @@ require 'puppet/util/log'
 require 'puppettest'
 
 class TestLog < Test::Unit::TestCase
-    include PuppetTest
-
-    def setup
-        super
-        @oldloglevel = Puppet::Util::Log.level
-        Puppet::Util::Log.close
-    end
-
-    def teardown
-        super
-        Puppet::Util::Log.close
-        Puppet::Util::Log.level = @oldloglevel
-        Puppet::Util::Log.newdestination(:console)
-    end
-
-    def getlevels
-        levels = nil
-        assert_nothing_raised() {
-            levels = []
-            Puppet::Util::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|
-            next if level == :alert
-            assert_nothing_raised() {
-                Puppet::Util::Log.new(
-                    :level => level,
-                    :source => "Test",
-                    :message => "Unit test for %s" % level
-                )
-            }
-        }
-    end
-
-    def test_logfile
-        fact = nil
-        levels = nil
-        Puppet::Util::Log.level = :debug
-        levels = getlevels
-        logfile = tempfile()
-        fact = nil
-        assert_nothing_raised() {
-            Puppet::Util::Log.newdestination(logfile)
-        }
-        msgs = mkmsgs(levels)
-        assert(msgs.length == levels.length)
-        Puppet::Util::Log.close
-        count = 0
-
-        assert(FileTest.exists?(logfile), "Did not create logfile")
-
-        assert_nothing_raised() {
-            File.open(logfile) { |of|
-                count = of.readlines.length
-            }
-        }
-        assert(count == levels.length - 1) # skip alert
-    end
-
-    def test_syslog
-        levels = nil
-        assert_nothing_raised() {
-            levels = getlevels.reject { |level|
-                level == :emerg || level == :crit
-            }
-        }
-        assert_nothing_raised() {
-            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_levelmethods
-        assert_nothing_raised() {
-            Puppet::Util::Log.newdestination("/dev/null")
-        }
-        getlevels.each { |level|
-            assert_nothing_raised() {
-                Puppet.send(level,"Testing for %s" % level)
-            }
-        }
-    end
-
-    def test_output
-        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::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::Util::Log.newdestination file
-        Puppet.info "testing logs"
-        assert(FileTest.directory?(dir))
-        assert(FileTest.file?(file))
-    end
-
-    # Verify that we can pass strings that match printf args
-    def test_percentlogs
-        Puppet::Util::Log.newdestination :syslog
-
-        assert_nothing_raised {
-            Puppet::Util::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.type(:file).new(
-            :path => tempfile(),
-            :check => %w{owner group}
+  include PuppetTest
+
+  def setup
+    super
+    @oldloglevel = Puppet::Util::Log.level
+    Puppet::Util::Log.close_all
+  end
+
+  def teardown
+    super
+    Puppet::Util::Log.close_all
+    Puppet::Util::Log.level = @oldloglevel
+  end
+
+  def getlevels
+    levels = nil
+    assert_nothing_raised {
+      levels = []
+      Puppet::Util::Log.eachlevel { |level| levels << level }
+    }
+    # Don't test the top levels; too annoying
+    levels.reject { |level| level == :emerg or level == :crit }
+  end
+
+  def mkmsgs(levels)
+    levels.collect { |level|
+      next if level == :alert
+      assert_nothing_raised {
+
+              Puppet::Util::Log.new(
+                
+          :level => level,
+          :source => "Test",
+        
+          :message => "Unit test for #{level}"
         )
-        assert_nothing_raised {
-            msg = Puppet::Util::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
+      }
+    }
+  end
+
+  def test_logfile
+    fact = nil
+    levels = nil
+    Puppet::Util::Log.level = :debug
+    levels = getlevels
+    logfile = tempfile
+    fact = nil
+    assert_nothing_raised {
+      Puppet::Util::Log.newdestination(logfile)
+    }
+    msgs = mkmsgs(levels)
+    assert(msgs.length == levels.length)
+    Puppet::Util::Log.close_all
+    count = 0
+
+    assert(FileTest.exists?(logfile), "Did not create logfile")
+
+    assert_nothing_raised {
+      File.open(logfile) { |of|
+        count = of.readlines.length
+      }
+    }
+    assert(count == levels.length - 1) # skip alert
+  end
+
+  def test_syslog
+    levels = nil
+    assert_nothing_raised {
+      levels = getlevels.reject { |level|
+        level == :emerg || level == :crit
+      }
+    }
+    assert_nothing_raised {
+      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_levelmethods
+    assert_nothing_raised {
+      Puppet::Util::Log.newdestination("/dev/null")
+    }
+    getlevels.each { |level|
+      assert_nothing_raised {
+        Puppet.send(level,"Testing for #{level}")
+      }
+    }
+  end
+
+  def test_output
+    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::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::Util::Log.newdestination file
+    Puppet.info "testing logs"
+    assert(FileTest.directory?(dir))
+    assert(FileTest.file?(file))
+  end
+
+  # Verify that we can pass strings that match printf args
+  def test_percentlogs
+    Puppet::Util::Log.newdestination :syslog
+
+    assert_nothing_raised {
 
-    def test_destination_matching
-        dest = nil
-        assert_nothing_raised {
-            dest = Puppet::Util::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)
+            Puppet::Util::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.type(:file).new(
+                
+      :path => tempfile,
+        
+      :check => %w{owner group}
+    )
+    assert_nothing_raised {
+      msg = Puppet::Util::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
+
+  def test_destination_matching
+    dest = nil
+    assert_nothing_raised {
+      dest = Puppet::Util::Log.newdesttype("Destine") do
+        def handle(msg)
+          puts msg
         end
+      end
+    }
 
-        assert_nothing_raised {
-            dest.match(:yayness)
-        }
-        assert(dest.match("Yayness"), "Did not match yayness")
-        Puppet::Util::Log.close(dest)
+    [:destine, "Destine", "destine"].each do |name|
+      assert(dest.match?(name), "Did not match #{name.inspect}")
     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
+    assert_nothing_raised {
+      dest.match(:yayness)
+    }
+    assert(dest.match("Yayness"), "Did not match yayness")
+    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