puppet 0.13.6 → 0.16.0

data/test/other/inifile.rb

@@ -0,0 +1,114 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/inifile'
+require 'puppettest'
+require 'test/unit'
+
+class TestFileType < Test::Unit::TestCase
+	include TestPuppet
+
+    def setup
+        super
+        @file = Puppet::IniConfig::File.new
+    end
+    
+    def teardown
+        @file = nil
+        super
+    end
+
+    def test_simple
+        fname = mkfile("[main]\nkey1=value1\n# Comment\nkey2=value2")
+        assert_nothing_raised {
+            @file.read(fname)
+        }
+        s = get_section('main')
+        assert_entries(s, { 'key1' => 'value1', 'key2' => 'value2' })
+        @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_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
+
+    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
+        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'])
+    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)
+        return result
+    end
+
+    def mkfile(content)
+        file = tempfile()
+        File.open(file, "w") { |f| f.print(content) }
+        return file
+    end
+end

data/test/other/log.rb

@@ -9,7 +9,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: log.rb 914 2006-02-15 21:04:14Z luke $
+# $Id: log.rb 1120 2006-04-19 23:38:25Z luke $
 
 class TestLog < Test::Unit::TestCase
     include TestPuppet
@@ -37,6 +37,7 @@ class TestLog < Test::Unit::TestCase
 
     def mkmsgs(levels)
         levels.collect { |level|
+            next if level == :alert
             assert_nothing_raised() {
                 Puppet::Log.new(
                     :level => level,
@@ -66,7 +67,7 @@ class TestLog < Test::Unit::TestCase
                 count = of.readlines.length
             }
         }
-        assert(count == levels.length)
+        assert(count == levels.length - 1) # skip alert
     end
 
     def test_syslog

data/test/other/transactions.rb

@@ -8,7 +8,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: transactions.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: transactions.rb 1113 2006-04-17 16:15:33Z luke $
 
 class TestTransactions < Test::Unit::TestCase
 	include FileTesting
@@ -33,12 +33,6 @@ class TestTransactions < Test::Unit::TestCase
         end
     end
 
-    def teardown
-        stopservices
-        #print "\n\n" if Puppet[:debug]
-        super
-    end
-
     def newfile(hash = {})
         tmpfile = tempfile()
         File.open(tmpfile, "w") { |f| f.puts rand(100) }
@@ -60,7 +54,6 @@ class TestTransactions < Test::Unit::TestCase
             File.chown(nil, firstgr, tmpfile)
         end
 
-        @@tmpfiles.push tmpfile
         hash[:name] = tmpfile
         assert_nothing_raised() {
             return Puppet.type(:file).create(hash)
@@ -74,7 +67,7 @@ class TestTransactions < Test::Unit::TestCase
                 :type => "init",
                 :path => File.join($puppetbase,"examples/root/etc/init.d"),
                 :hasstatus => true,
-                :check => [:running]
+                :check => [:ensure]
             )
         }
     end
@@ -147,7 +140,7 @@ class TestTransactions < Test::Unit::TestCase
         component = newcomp("service",service)
 
         assert_nothing_raised() {
-            service[:running] = 1
+            service[:ensure] = 1
         }
         service.retrieve
         assert(service.insync?, "Service did not start")
@@ -232,4 +225,56 @@ class TestTransactions < Test::Unit::TestCase
 
     end
 
+    # Make sure that multiple subscriptions get triggered.
+    def test_multisubs
+        path = tempfile()
+        file1 = tempfile()
+        file2 = tempfile()
+        file = Puppet.type(:file).create(
+            :path => path,
+            :ensure => "file"
+        )
+        exec1 = Puppet.type(:exec).create(
+            :path => ENV["PATH"],
+            :command => "touch %s" % file1,
+            :refreshonly => true,
+            :subscribe => [:file, path]
+        )
+        exec2 = Puppet.type(:exec).create(
+            :path => ENV["PATH"],
+            :command => "touch %s" % file2,
+            :refreshonly => true,
+            :subscribe => [:file, path]
+        )
+
+        assert_apply(file, exec1, exec2)
+        assert(FileTest.exists?(file1), "File 1 did not get created")
+        assert(FileTest.exists?(file2), "File 2 did not get created")
+    end
+
+    # Make sure that a failed trigger doesn't result in other events not
+    # getting triggered.
+    def test_failedrefreshes
+        path = tempfile()
+        newfile = tempfile()
+        file = Puppet.type(:file).create(
+            :path => path,
+            :ensure => "file"
+        )
+        svc = Puppet.type(:service).create(
+            :name => "thisservicedoesnotexist",
+            :subscribe => [:file, path]
+        )
+        exec = Puppet.type(:exec).create(
+            :path => ENV["PATH"],
+            :command => "touch %s" % newfile,
+            :logoutput => true,
+            :refreshonly => true,
+            :subscribe => [:file, path]
+        )
+
+        assert_apply(file, svc, exec)
+        assert(FileTest.exists?(path), "File did not get created")
+        assert(FileTest.exists?(newfile), "Refresh file did not get created")
+    end
 end

data/test/puppet/utiltest.rb

@@ -157,6 +157,30 @@ class TestPuppetUtil < Test::Unit::TestCase
         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 = Puppet::Util.benchmark(:notice, "Read file") do
+                File.read(path)
+            end
+
+            assert_equal(str, val)
+        end
+
+        # Now test it with a passed object
+        assert_nothing_raised do
+            val = Puppet::Util.benchmark(Puppet, :notice, "Read file") do
+                File.read(path)
+            end
+
+            assert_equal(str, val)
+        end
+    end
+
     unless Process.uid == 0
         $stderr.puts "Run as root to perform Utility tests"
         def test_nothing
@@ -267,4 +291,4 @@ class TestPuppetUtil < Test::Unit::TestCase
     end
 end
 
-# $Id: utiltest.rb 967 2006-03-02 20:28:45Z luke $
+# $Id: utiltest.rb 1098 2006-04-10 22:13:10Z luke $

data/test/puppettest.rb

@@ -24,6 +24,7 @@ module TestPuppet
     end
 
     def setup
+        @memoryatstart = Puppet::Util.memory
         if defined? @@testcount
             @@testcount += 1
         else
@@ -34,6 +35,13 @@ module TestPuppet
             self.class.to_s + "configdir" + @@testcount.to_s + "/"
         )
 
+        unless defined? $user and $group
+            $user = nonrootuser().uid.to_s
+            $group = nonrootgroup().gid.to_s
+        end
+        Puppet[:user] = $user
+        Puppet[:group] = $group
+
         Puppet[:confdir] = @configpath
         Puppet[:vardir] = @configpath
 
@@ -44,6 +52,8 @@ module TestPuppet
         @@tmpfiles = [@configpath, tmpdir()]
         @@tmppids = []
 
+        @@cleaners = []
+
         if $0 =~ /.+\.rb/ or Puppet[:debug]
             Puppet::Log.newdestination :console
             Puppet::Log.level = :debug
@@ -90,14 +100,21 @@ module TestPuppet
     def stopservices
         if stype = Puppet::Type.type(:service)
             stype.each { |service|
-                service[:running] = false
+                service[:ensure] = :stopped
                 service.evaluate
             }
         end
     end
 
+    def cleanup(&block)
+        @@cleaners << block
+    end
+
     def teardown
         stopservices
+
+        @@cleaners.each { |cleaner| cleaner.call() }
+
         @@tmpfiles.each { |file|
             if FileTest.exists?(file)
                 system("chmod -R 755 %s" % file)
@@ -115,6 +132,14 @@ module TestPuppet
         Puppet::Storage.clear
         Puppet.clear
 
+        @memoryatend = Puppet::Util.memory
+        diff = @memoryatend - @memoryatstart
+
+        if diff > 1000
+            Puppet.info "%s#%s memory growth (%s to %s): %s" %
+                [self.class, @method_name, @memoryatstart, @memoryatend, diff]
+        end
+
         # reset all of the logs
         Puppet::Log.close
 
@@ -129,23 +154,24 @@ module TestPuppet
     end
 
     def tempfile
-        if defined? @tmpfilenum
-            @tmpfilenum += 1
+        if defined? @@tmpfilenum
+            @@tmpfilenum += 1
         else
-            @tmpfilenum = 1
+            @@tmpfilenum = 1
         end
-        f = File.join(self.tmpdir(), self.class.to_s + "testfile" + @tmpfilenum.to_s)
+
+        f = File.join(self.tmpdir(), self.class.to_s + "testfile" + @@tmpfilenum.to_s)
         @@tmpfiles << f
         return f
     end
 
     def tstdir
-        if defined? @testdirnum
-            @testdirnum += 1
+        if defined? @@testdirnum
+            @@testdirnum += 1
         else
-            @testdirnum = 1
+            @@testdirnum = 1
         end
-        d = File.join(self.tmpdir(), self.class.to_s + "testdir" + @testdirnum.to_s)
+        d = File.join(self.tmpdir(), self.class.to_s + "testdir" + @@testdirnum.to_s)
         @@tmpfiles << d
         return d
     end
@@ -285,6 +311,15 @@ module TestPuppet
 
         return files
     end
+
+    # wrap how to retrieve the masked mode
+    def filemode(file)
+        File.stat(file).mode & 007777
+    end
+
+    def memory
+        Puppet::Util.memory
+    end
 end
 
 
@@ -322,7 +357,7 @@ module ServerTest
             handlers = {
                 :CA => {}, # so that certs autogenerate
                 :Master => {
-                    :File => mktestmanifest(),
+                    :Manifest => mktestmanifest(),
                     :UseNodes => false
                 },
             }
@@ -433,6 +468,7 @@ module ExeTest
             File.unlink(pidfile)
         end
 
+        return unless running
         if running or pid
             runningpid = nil
             %x{#{ps}}.chomp.split(/\n/).each { |line|
@@ -443,12 +479,6 @@ module ExeTest
                 end
             }
 
-            if running
-                assert(runningpid, "Process is not running")
-                assert_equal(pid, runningpid, "PIDs are not equal")
-            else
-                return
-            end
         end
 
         # we default to mandating that it's running, but teardown
@@ -708,28 +738,44 @@ module ParserTesting
     end
 
     def classobj(name, args = {})
-        unless args.include?(:name)
-            args[:type] = nameobj(name)
-        end
-        unless args.include?(:code)
-            args[:code] = AST::ASTArray.new(
-                :file => tempfile(),
-                :line => rand(100),
-                :children => [
-                    varobj("%svar" % name, "%svalue" % name),
-                    fileobj("/%s" % name)
-                ]
-            )
-        end
+        args[:type] ||= nameobj(name)
+        args[:code] ||= AST::ASTArray.new(
+            :file => __FILE__,
+            :line => __LINE__,
+            :children => [
+                varobj("%svar" % name, "%svalue" % name),
+                fileobj("/%s" % name)
+            ]
+        )
         assert_nothing_raised("Could not create class %s" % name) {
             return AST::ClassDef.new(args)
         }
     end
 
+    def tagobj(*names)
+        args = {}
+        newnames = names.collect do |name|
+            if name.is_a? AST
+                name
+            else
+                nameobj(name)
+            end
+        end
+        args[:type] = astarray(*newnames)
+        assert_nothing_raised("Could not create tag %s" % names.inspect) {
+            return AST::Tag.new(args)
+        }
+    end
+
     def compobj(name, args = {})
         args[:file] ||= tempfile()
         args[:line] ||= rand(100)
         args[:type] ||= nameobj(name)
+        args[:args] ||= AST::ASTArray.new(
+            :file => tempfile(),
+            :line => rand(100),
+            :children => []
+        )
         args[:code] ||= AST::ASTArray.new(
             :file => tempfile(),
             :line => rand(100),
@@ -765,7 +811,17 @@ module ParserTesting
         }
     end
 
-    def nodeobj(name)
+    def typeobj(name)
+        assert_nothing_raised("Could not create type %s" % name) {
+            return AST::Type.new(
+                :file => tempfile(),
+                :line => rand(100),
+                :value => name
+            )
+        }
+    end
+
+    def nodedef(name)
         assert_nothing_raised("Could not create node %s" % name) {
             return AST::NodeDef.new(
                 :file => tempfile(),
@@ -824,6 +880,16 @@ module ParserTesting
         }
     end
 
+    def varref(name)
+        assert_nothing_raised("Could not create %s variable" % name) {
+            return AST::Variable.new(
+                :file => __FILE__,
+                :line => __LINE__,
+                :value => name
+            )
+        }
+    end
+
     def argobj(name, value)
         assert_nothing_raised("Could not create %s compargument" % name) {
             return AST::CompArgument.new(
@@ -831,6 +897,32 @@ module ParserTesting
             )
         }
     end
+
+    def defaultobj(type, params)
+        pary = []
+        params.each { |p,v|
+            pary << AST::ObjectParam.new(
+                :file => __FILE__,
+                :line => __LINE__,
+                :param => nameobj(p),
+                :value => stringobj(v)
+            )
+        }
+        past = AST::ASTArray.new(
+            :file => __FILE__,
+            :line => __LINE__,
+            :children => pary
+        )
+
+        assert_nothing_raised("Could not create defaults for %s" % type) {
+            return AST::TypeDefaults.new(
+                :file => __FILE__,
+                :line => __LINE__,
+                :type => typeobj(type),
+                :params => past
+            )
+        }
+    end
 end
 
 class PuppetTestSuite
@@ -853,24 +945,26 @@ class PuppetTestSuite
 
     def initialize(name)
         path = File.join(self.class.basedir, name)
-        unless FileTest.directory?(path)
-            puts "TestSuites are directories containing test cases"
+        if FileTest.directory?(path)
+            # load each of the files
+            Dir.entries(path).collect { |file|
+                File.join(path,file)
+            }.find_all { |file|
+                FileTest.file?(file) and file =~ /\.rb$/
+            }.sort { |a,b|
+                # in the order they were modified, so the last modified files
+                # are loaded and thus displayed last
+                File.stat(b) <=> File.stat(a)
+            }.each { |file|
+                require file
+            }
+        elsif FileTest.file?(path) && path =~ /\.rb$/
+            require path
+        else
+            puts "TestSuites are directories or files containing test cases"
             puts "no such directory: %s" % path
             exit(65)
         end
-
-        # load each of the files
-        Dir.entries(path).collect { |file|
-            File.join(path,file)
-        }.find_all { |file|
-            FileTest.file?(file) and file =~ /\.rb$/
-        }.sort { |a,b|
-            # in the order they were modified, so the last modified files
-            # are loaded and thus displayed last
-            File.stat(b) <=> File.stat(a)
-        }.each { |file|
-            require file
-        }
     end
 end
 
@@ -901,4 +995,4 @@ def failers
     }
 end
 
-# $Id: puppettest.rb 967 2006-03-02 20:28:45Z luke $
+# $Id: puppettest.rb 1113 2006-04-17 16:15:33Z luke $