puppet 0.25.5 → 2.6.0

data/test/util/storage.rb

@@ -6,93 +6,76 @@ require 'puppet'
 require 'puppettest'
 
 class TestStorage < Test::Unit::TestCase
-    include PuppetTest
-
-    def mkfile
-        path = tempfile()
-        File.open(path, "w") { |f| f.puts :yayness }
-
-        f = Puppet::Type.type(:file).new(
-            :name => path,
-            :check => %w{checksum type}
-        )
-
-        return f
-    end
-
-    def test_storeandretrieve
-        path = tempfile()
-
-        f = mkfile()
-
-        # Load first, since that's what we do in the code base; this creates
-        # all of the necessary directories.
-        assert_nothing_raised {
-            Puppet::Util::Storage.load
-        }
-
-        hash = {:a => :b, :c => :d}
-
-        state = nil
-        assert_nothing_raised {
-            state = Puppet::Util::Storage.cache(f)
-        }
-
-        assert(!state.include?("name"))
-
-        assert_nothing_raised {
-            state["name"] = hash
-        }
-
-        assert_nothing_raised {
-            Puppet::Util::Storage.store
-        }
-        assert_nothing_raised {
-            Puppet::Util::Storage.clear
-        }
-        assert_nothing_raised {
-            Puppet::Util::Storage.load
-        }
-
-        # Reset it
-        state = nil
-        assert_nothing_raised {
-            state = Puppet::Util::Storage.cache(f)
-        }
-
-        assert_equal(state["name"], hash)
-    end
-
-    def test_emptyrestore
-        Puppet::Util::Storage.load
-        Puppet::Util::Storage.store
-        Puppet::Util::Storage.clear
-        Puppet::Util::Storage.load
-
-        f = mkfile()
-        state = Puppet::Util::Storage.cache(f)
-        assert_same Hash, state.class
-        assert_equal 0, state.size
-    end
-
-    def test_caching
-        hash = nil
-        one = Puppet::Type.type(:exec).new :title => "/bin/echo one"
-        [one, :yayness].each do |object|
-            assert_nothing_raised do
-                hash = Puppet::Util::Storage.cache(object)
-            end
-            assert_equal({}, hash, "Did not get empty hash back for %s" % object)
-
-            hash[:testing] = true
-            assert_nothing_raised do
-                hash = Puppet::Util::Storage.cache(object)
-            end
-            assert_equal({:testing => true}, hash, "Did not get hash back for %s" % object)
-        end
-        assert_raise(ArgumentError, "was able to cache from string") do
-            Puppet::Util::Storage.cache("somethingelse")
-        end
-    end
+  include PuppetTest
+
+  def mkfile
+    path = tempfile
+    File.open(path, "w") { |f| f.puts :yayness }
+
+
+          f = Puppet::Type.type(:file).new(
+                
+      :name => path,
+        
+      :check => %w{checksum type}
+    )
+
+    f
+  end
+
+  def test_storeandretrieve
+    path = tempfile
+
+    f = mkfile
+
+    # Load first, since that's what we do in the code base; this creates
+    # all of the necessary directories.
+    assert_nothing_raised {
+      Puppet::Util::Storage.load
+    }
+
+    hash = {:a => :b, :c => :d}
+
+    state = nil
+    assert_nothing_raised {
+      state = Puppet::Util::Storage.cache(f)
+    }
+
+    assert(!state.include?("name"))
+
+    assert_nothing_raised {
+      state["name"] = hash
+    }
+
+    assert_nothing_raised {
+      Puppet::Util::Storage.store
+    }
+    assert_nothing_raised {
+      Puppet::Util::Storage.clear
+    }
+    assert_nothing_raised {
+      Puppet::Util::Storage.load
+    }
+
+    # Reset it
+    state = nil
+    assert_nothing_raised {
+      state = Puppet::Util::Storage.cache(f)
+    }
+
+    assert_equal(state["name"], hash)
+  end
+
+  def test_emptyrestore
+    Puppet::Util::Storage.load
+    Puppet::Util::Storage.store
+    Puppet::Util::Storage.clear
+    Puppet::Util::Storage.load
+
+    f = mkfile
+    state = Puppet::Util::Storage.cache(f)
+    assert_same Hash, state.class
+    assert_equal 0, state.size
+  end
 end
 

data/test/util/subclass_loader.rb

@@ -6,87 +6,84 @@ require 'puppettest'
 require 'puppet/util/subclass_loader'
 
 class TestPuppetUtilSubclassLoader < Test::Unit::TestCase
-    include PuppetTest
-
-    class LoadTest
-        extend Puppet::Util::SubclassLoader
-        handle_subclasses :faker, "puppet/fakeloaders"
+  include PuppetTest
+
+  class LoadTest
+    extend Puppet::Util::SubclassLoader
+    handle_subclasses :faker, "puppet/fakeloaders"
+  end
+
+  def mk_subclass(name, path, parent)
+    # Make a fake client
+    unless defined?(@basedir)
+      @basedir ||= tempfile
+      $LOAD_PATH << @basedir
+      cleanup { $LOAD_PATH.delete(@basedir) if $LOAD_PATH.include?(@basedir) }
     end
 
-    def mk_subclass(name, path, parent)
-        # Make a fake client
-        unless defined? @basedir
-            @basedir ||= tempfile()
-            $: << @basedir
-            cleanup { $:.delete(@basedir) if $:.include?(@basedir) }
-        end
-
-        libdir = File.join([@basedir, path.split(File::SEPARATOR)].flatten)
-        FileUtils.mkdir_p(libdir)
-
-        file = File.join(libdir, "#{name}.rb")
-        File.open(file, "w") do |f|
-            f.puts %{class #{parent}::#{name.to_s.capitalize} < #{parent}; end}
-        end
-    end
+    libdir = File.join([@basedir, path.split(File::SEPARATOR)].flatten)
+    FileUtils.mkdir_p(libdir)
 
-    def test_subclass_loading
-        # Make a fake client
-        mk_subclass("fake", "puppet/fakeloaders", "TestPuppetUtilSubclassLoader::LoadTest")
+    file = File.join(libdir, "#{name}.rb")
+    File.open(file, "w") do |f|
+      f.puts %{class #{parent}::#{name.to_s.capitalize} < #{parent}; end}
+    end
+  end
 
+  def test_subclass_loading
+    # Make a fake client
+    mk_subclass("fake", "puppet/fakeloaders", "TestPuppetUtilSubclassLoader::LoadTest")
 
-        fake = nil
-        assert_nothing_raised do
-            fake = LoadTest.faker(:fake)
-        end
-        assert_nothing_raised do
-            assert_equal(fake, LoadTest.fake,
-                "Did not get subclass back from main method")
-        end
-        assert(fake, "did not load subclass")
 
-        # Now make sure the subclass behaves correctly
-        assert_equal(:Fake, fake.name, "name was not calculated correctly")
+    fake = nil
+    assert_nothing_raised do
+      fake = LoadTest.faker(:fake)
     end
-
-    def test_multiple_subclasses
-        sub1 = Class.new(LoadTest)
-        Object.const_set("Sub1", sub1)
-        sub2 = Class.new(sub1)
-        Object.const_set("Sub2", sub2)
-        assert_equal(sub2, LoadTest.sub2, "did not get subclass of subclass")
+    assert_nothing_raised do
+      assert_equal(fake, LoadTest.fake, "Did not get subclass back from main method")
     end
+    assert(fake, "did not load subclass")
+
+    # Now make sure the subclass behaves correctly
+    assert_equal(:Fake, fake.name, "name was not calculated correctly")
+  end
+
+  def test_multiple_subclasses
+    sub1 = Class.new(LoadTest)
+    Object.const_set("Sub1", sub1)
+    sub2 = Class.new(sub1)
+    Object.const_set("Sub2", sub2)
+    assert_equal(sub2, LoadTest.sub2, "did not get subclass of subclass")
+  end
+
+  # I started out using a class variable to mark the loader,
+  # but it's shared among all classes that include this module,
+  # so it didn't work.  This is testing whether I get the behaviour
+  # that I want.
+  def test_multiple_classes_using_module
+    other = Class.new do
+      extend Puppet::Util::SubclassLoader
+      handle_subclasses :other, "puppet/other"
+    end
+    Object.const_set("OtherLoader", other)
+
+    mk_subclass("multipletest", "puppet/other", "OtherLoader")
+    mk_subclass("multipletest", "puppet/fakeloaders", "TestPuppetUtilSubclassLoader::LoadTest")
+    #system("find #{@basedir}")
+    #puts File.read(File.join(@basedir, "puppet/fakeloaders/multipletest.rb"))
+    #puts File.read(File.join(@basedir, "puppet/other/multipletest.rb"))
 
-    # I started out using a class variable to mark the loader,
-    # but it's shared among all classes that include this module,
-    # so it didn't work.  This is testing whether I get the behaviour
-    # that I want.
-    def test_multiple_classes_using_module
-        other = Class.new do
-            extend Puppet::Util::SubclassLoader
-            handle_subclasses :other, "puppet/other"
-        end
-        Object.const_set("OtherLoader", other)
-
-        mk_subclass("multipletest", "puppet/other", "OtherLoader")
-        mk_subclass("multipletest", "puppet/fakeloaders", "TestPuppetUtilSubclassLoader::LoadTest")
-        #system("find %s" % @basedir)
-        #puts File.read(File.join(@basedir, "puppet/fakeloaders/multipletest.rb"))
-        #puts File.read(File.join(@basedir, "puppet/other/multipletest.rb"))
-
-        othersub = mainsub = nil
-        assert_nothing_raised("Could not look up other sub") do
-            othersub = OtherLoader.other(:multipletest)
-        end
-        assert_nothing_raised("Could not look up main sub") do
-            mainsub = LoadTest.faker(:multipletest)
-        end
-        assert(othersub, "did not get other sub")
-        assert(mainsub, "did not get main sub")
-        assert(othersub.ancestors.include?(OtherLoader),
-            "othersub is not a subclass of otherloader")
-        assert(mainsub.ancestors.include?(LoadTest),
-            "mainsub is not a subclass of loadtest")
+    othersub = mainsub = nil
+    assert_nothing_raised("Could not look up other sub") do
+      othersub = OtherLoader.other(:multipletest)
+    end
+    assert_nothing_raised("Could not look up main sub") do
+      mainsub = LoadTest.faker(:multipletest)
     end
+    assert(othersub, "did not get other sub")
+    assert(mainsub, "did not get main sub")
+    assert(othersub.ancestors.include?(OtherLoader), "othersub is not a subclass of otherloader")
+    assert(mainsub.ancestors.include?(LoadTest), "mainsub is not a subclass of loadtest")
+  end
 end
 

data/test/util/utiltest.rb

@@ -6,230 +6,231 @@ require 'puppettest'
 require 'mocha'
 
 class TestPuppetUtil < Test::Unit::TestCase
-    include PuppetTest
+  include PuppetTest
 
-    def test_withumask
-        oldmask = File.umask
+  def test_withumask
+    oldmask = File.umask
 
-        path = tempfile()
+    path = tempfile
 
-        # FIXME this fails on FreeBSD with a mode of 01777
-        Puppet::Util.withumask(000) do
-            Dir.mkdir(path, 0777)
-        end
-
-        assert(File.stat(path).mode & 007777 == 0777, "File has the incorrect mode")
-        assert_equal(oldmask, File.umask, "Umask was not reset")
+    # FIXME this fails on FreeBSD with a mode of 01777
+    Puppet::Util.withumask(000) do
+      Dir.mkdir(path, 0777)
     end
 
-    def test_benchmark
-        path = tempfile()
-        str = "yayness"
-        File.open(path, "w") do |f| f.print "yayness" end
+    assert(File.stat(path).mode & 007777 == 0777, "File has the incorrect mode")
+    assert_equal(oldmask, File.umask, "Umask was not reset")
+  end
+
+  def test_benchmark
+    path = tempfile
+    str = "yayness"
+    File.open(path, "w") do |f| f.print "yayness" end
 
-        # First test it with the normal args
-        assert_nothing_raised do
-            val = nil
-            result = Puppet::Util.benchmark(:notice, "Read file") do
-                val = File.read(path)
-            end
+    # First test it with the normal args
+    assert_nothing_raised do
+      val = nil
+      result = Puppet::Util.benchmark(:notice, "Read file") do
+        val = File.read(path)
+      end
 
-            assert_equal(str, val)
+      assert_equal(str, val)
 
-            assert_instance_of(Float, result)
+      assert_instance_of(Float, result)
 
-        end
+    end
 
-        # Now test it with a passed object
-        assert_nothing_raised do
-            val = nil
-            Puppet::Util.benchmark(Puppet, :notice, "Read file") do
-                val = File.read(path)
-            end
+    # Now test it with a passed object
+    assert_nothing_raised do
+      val = nil
+      Puppet::Util.benchmark(Puppet, :notice, "Read file") do
+        val = File.read(path)
+      end
 
-            assert_equal(str, val)
-        end
+      assert_equal(str, val)
     end
+  end
 
-    def test_proxy
-        klass = Class.new do
-            attr_accessor :hash
-            class << self
-                attr_accessor :ohash
-            end
-        end
-        klass.send(:include, Puppet::Util)
-
-        klass.ohash = {}
-
-        inst = klass.new
-        inst.hash = {}
-        assert_nothing_raised do
-            Puppet::Util.proxy klass, :hash, "[]", "[]=", :clear, :delete
-        end
-
-        assert_nothing_raised do
-            Puppet::Util.classproxy klass, :ohash, "[]", "[]=", :clear, :delete
-        end
-
-        assert_nothing_raised do
-            inst[:yay] = "boo"
-            inst["cool"] = :yayness
-        end
-
-        [:yay, "cool"].each do |var|
-            assert_equal(inst.hash[var], inst[var],
-                        "Var %s did not take" % var)
-        end
-
-        assert_nothing_raised do
-            klass[:Yay] = "boo"
-            klass["Cool"] = :yayness
-        end
-
-        [:Yay, "Cool"].each do |var|
-            assert_equal(inst.hash[var], inst[var],
-                        "Var %s did not take" % var)
-        end
-    end
-
-    def test_symbolize
-        ret = nil
-        assert_nothing_raised {
-            ret = Puppet::Util.symbolize("yayness")
-        }
-
-        assert_equal(:yayness, ret)
-
-        assert_nothing_raised {
-            ret = Puppet::Util.symbolize(:yayness)
-        }
-
-        assert_equal(:yayness, ret)
-
-        assert_nothing_raised {
-            ret = Puppet::Util.symbolize(43)
-        }
-
-        assert_equal(43, ret)
-
-        assert_nothing_raised {
-            ret = Puppet::Util.symbolize(nil)
-        }
-
-        assert_equal(nil, ret)
-    end
-
-    def test_execute
-        command = tempfile()
-        File.open(command, "w") { |f|
-            f.puts %{#!/bin/sh\n/bin/echo "$1">&1; echo "$2">&2}
-        }
-        File.chmod(0755, command)
-        output = nil
-        assert_nothing_raised do
-            output = Puppet::Util.execute([command, "yaytest", "funtest"])
-        end
-        assert_equal("yaytest\nfuntest\n", output)
-
-        # Now try it with a single quote
-        assert_nothing_raised do
-            output = Puppet::Util.execute([command, "yay'test", "funtest"])
-        end
-        assert_equal("yay'test\nfuntest\n", output)
-
-        # Now make sure we can squelch output (#565)
-        assert_nothing_raised do
-            output = Puppet::Util.execute([command, "yay'test", "funtest"], :squelch => true)
-        end
-        assert_equal(nil, output)
-
-        # Now test that we correctly fail if the command returns non-zero
-        assert_raise(Puppet::ExecutionFailure) do
-            out = Puppet::Util.execute(["touch", "/no/such/file/could/exist"])
-        end
-
-        # And that we can tell it not to fail
-        assert_nothing_raised() do
-            out = Puppet::Util.execute(["touch", "/no/such/file/could/exist"], :failonfail => false)
-        end
-
-        if Process.uid == 0
-            # Make sure we correctly set our uid and gid
-            user = nonrootuser
-            group = nonrootgroup
-            file = tempfile()
-            assert_nothing_raised do
-                Puppet::Util.execute(["touch", file], :uid => user.name, :gid => group.name)
-            end
-            assert(FileTest.exists?(file), "file was not created")
-            assert_equal(user.uid, File.stat(file).uid, "uid was not set correctly")
-
-            # We can't really check the gid, because it just behaves too
-            # inconsistently everywhere.
-            # assert_equal(group.gid, File.stat(file).gid,
-            #    "gid was not set correctly")
-        end
-
-        # (#565) Test the case of patricide.
-        patricidecommand = tempfile()
-        File.open(patricidecommand, "w") { |f|
-            f.puts %{#!/bin/bash\n/bin/bash -c 'kill -TERM \$PPID' &;\n while [ 1 ]; do echo -n ''; done;\n}
-        }
-        File.chmod(0755, patricidecommand)
-        assert_nothing_raised do
-            output = Puppet::Util.execute([patricidecommand], :squelch => true)
-        end
-        assert_equal(nil, output)
-        # See what happens if we try and read the pipe to the command...
-        assert_raise(Puppet::ExecutionFailure) do
-            output = Puppet::Util.execute([patricidecommand])
-        end
-        assert_nothing_raised do
-            output = Puppet::Util.execute([patricidecommand], :failonfail => false)
-        end
-    end
-
-    def test_lang_environ_in_execute
-      orig_lang = ENV["LANG"]
-      orig_lc_all = ENV["LC_ALL"]
-      orig_lc_messages = ENV["LC_MESSAGES"]
-      orig_language = ENV["LANGUAGE"]
-
-      cleanup do
-          ENV["LANG"] = orig_lang
-          ENV["LC_ALL"] = orig_lc_all
-          ENV["LC_MESSAGES"] = orig_lc_messages
-          ENV["LANGUAGE"] = orig_lc_messages
+  def test_proxy
+    klass = Class.new do
+      attr_accessor :hash
+      class << self
+        attr_accessor :ohash
       end
+    end
+    klass.send(:include, Puppet::Util)
+
+    klass.ohash = {}
+
+    inst = klass.new
+    inst.hash = {}
+    assert_nothing_raised do
+      Puppet::Util.proxy klass, :hash, "[]", "[]=", :clear, :delete
+    end
+
+    assert_nothing_raised do
+      Puppet::Util.classproxy klass, :ohash, "[]", "[]=", :clear, :delete
+    end
+
+    assert_nothing_raised do
+      inst[:yay] = "boo"
+      inst["cool"] = :yayness
+    end
+
+    [:yay, "cool"].each do |var|
+      assert_equal(inst.hash[var], inst[var], "Var #{var} did not take")
+    end
+
+    assert_nothing_raised do
+      klass[:Yay] = "boo"
+      klass["Cool"] = :yayness
+    end
+
+    [:Yay, "Cool"].each do |var|
+      assert_equal(inst.hash[var], inst[var], "Var #{var} did not take")
+    end
+  end
+
+  def test_symbolize
+    ret = nil
+    assert_nothing_raised {
+      ret = Puppet::Util.symbolize("yayness")
+    }
+
+    assert_equal(:yayness, ret)
+
+    assert_nothing_raised {
+      ret = Puppet::Util.symbolize(:yayness)
+    }
+
+    assert_equal(:yayness, ret)
 
-      # Mmm, we love gettext(3)
-      ENV["LANG"] = "en_US"
-      ENV["LC_ALL"] = "en_US"
-      ENV["LC_MESSAGES"] = "en_US"
-      ENV["LANGUAGE"] = "en_US"
+    assert_nothing_raised {
+      ret = Puppet::Util.symbolize(43)
+    }
 
-      %w{LANG LC_ALL LC_MESSAGES LANGUAGE}.each do |env|
-        assert_equal('C',
-                     Puppet::Util.execute(['ruby', '-e', "print ENV['#{env}']"]),
-                     "Environment var #{env} wasn't set to 'C'")
+    assert_equal(43, ret)
 
-        assert_equal 'en_US', ENV[env], "Environment var #{env} not set back correctly"
+    assert_nothing_raised {
+      ret = Puppet::Util.symbolize(nil)
+    }
+
+    assert_equal(nil, ret)
+  end
+
+  def test_execute
+    command = tempfile
+    File.open(command, "w") { |f|
+      f.puts %{#!/bin/sh\n/bin/echo "$1">&1; echo "$2">&2}
+    }
+    File.chmod(0755, command)
+    output = nil
+    assert_nothing_raised do
+      output = Puppet::Util.execute([command, "yaytest", "funtest"])
+    end
+    assert_equal("yaytest\nfuntest\n", output)
+
+    # Now try it with a single quote
+    assert_nothing_raised do
+      output = Puppet::Util.execute([command, "yay'test", "funtest"])
+    end
+    assert_equal("yay'test\nfuntest\n", output)
+
+    # Now make sure we can squelch output (#565)
+    assert_nothing_raised do
+      output = Puppet::Util.execute([command, "yay'test", "funtest"], :squelch => true)
+    end
+    assert_equal(nil, output)
+
+    # Now test that we correctly fail if the command returns non-zero
+    assert_raise(Puppet::ExecutionFailure) do
+      out = Puppet::Util.execute(["touch", "/no/such/file/could/exist"])
+    end
+
+    # And that we can tell it not to fail
+    assert_nothing_raised do
+      out = Puppet::Util.execute(["touch", "/no/such/file/could/exist"], :failonfail => false)
+    end
+
+    if Process.uid == 0
+      # Make sure we correctly set our uid and gid
+      user = nonrootuser
+      group = nonrootgroup
+      file = tempfile
+      assert_nothing_raised do
+        Puppet::Util.execute(["touch", file], :uid => user.name, :gid => group.name)
       end
+      assert(FileTest.exists?(file), "file was not created")
+      assert_equal(user.uid, File.stat(file).uid, "uid was not set correctly")
 
+      # We can't really check the gid, because it just behaves too
+      # inconsistently everywhere.
+      # assert_equal(group.gid, File.stat(file).gid,
+      #    "gid was not set correctly")
     end
 
-    # Check whether execute() accepts strings in addition to arrays.
-    def test_string_exec
-        cmd = "/bin/echo howdy"
-        output = nil
-        assert_raise(ArgumentError) {
-            output = Puppet::Util.execute(cmd)
-        }
-        #assert_equal("howdy\n", output)
-        #assert_raise(RuntimeError) {
-        #    Puppet::Util.execute(cmd, 0, 0)
-        #}
+    # (#565) Test the case of patricide.
+    patricidecommand = tempfile
+    File.open(patricidecommand, "w") { |f|
+      f.puts %{#!/bin/bash\n/bin/bash -c 'kill -TERM \$PPID' &;\n while [ 1 ]; do echo -n ''; done;\n}
+    }
+    File.chmod(0755, patricidecommand)
+    assert_nothing_raised do
+      output = Puppet::Util.execute([patricidecommand], :squelch => true)
+    end
+    assert_equal(nil, output)
+    # See what happens if we try and read the pipe to the command...
+    assert_raise(Puppet::ExecutionFailure) do
+      output = Puppet::Util.execute([patricidecommand])
+    end
+    assert_nothing_raised do
+      output = Puppet::Util.execute([patricidecommand], :failonfail => false)
     end
+  end
+
+  def test_lang_environ_in_execute
+    orig_lang = ENV["LANG"]
+    orig_lc_all = ENV["LC_ALL"]
+    orig_lc_messages = ENV["LC_MESSAGES"]
+    orig_language = ENV["LANGUAGE"]
+
+    cleanup do
+      ENV["LANG"] = orig_lang
+      ENV["LC_ALL"] = orig_lc_all
+      ENV["LC_MESSAGES"] = orig_lc_messages
+      ENV["LANGUAGE"] = orig_lc_messages
+    end
+
+    # Mmm, we love gettext(3)
+    ENV["LANG"] = "en_US"
+    ENV["LC_ALL"] = "en_US"
+    ENV["LC_MESSAGES"] = "en_US"
+    ENV["LANGUAGE"] = "en_US"
+
+    %w{LANG LC_ALL LC_MESSAGES LANGUAGE}.each do |env|
+
+      assert_equal(
+        'C',
+          Puppet::Util.execute(['ruby', '-e', "print ENV['#{env}']"]),
+
+          "Environment var #{env} wasn't set to 'C'")
+
+      assert_equal 'en_US', ENV[env], "Environment var #{env} not set back correctly"
+    end
+
+  end
+
+  # Check whether execute accepts strings in addition to arrays.
+  def test_string_exec
+    cmd = "/bin/echo howdy"
+    output = nil
+    assert_raise(ArgumentError) {
+      output = Puppet::Util.execute(cmd)
+    }
+    #assert_equal("howdy\n", output)
+    #assert_raise(RuntimeError) {
+    #    Puppet::Util.execute(cmd, 0, 0)
+    #}
+  end
 end