puppet 0.16.0 → 0.18.4

data/test/language/snippets.rb

@@ -25,6 +25,7 @@ require 'puppettest'
 
 class TestSnippets < Test::Unit::TestCase
 	include TestPuppet
+    include ObjectSpace
     $snippetbase = File.join($puppetbase, "examples", "code", "snippets")
     
     def file2ast(file)
@@ -186,7 +187,7 @@ class TestSnippets < Test::Unit::TestCase
         assert_nothing_raised {
             trans.rollback
         }
-        assert(! FileTest.exists?(file))
+        assert(! FileTest.exists?(file), "%s still exists" % file)
     end
 
     def snippet_simpleselector(trans)
@@ -206,7 +207,7 @@ class TestSnippets < Test::Unit::TestCase
             trans.rollback
         }
         files.each { |file|
-            assert(! FileTest.exists?(file))
+            assert(! FileTest.exists?(file), "%s still exists" % file)
         }
     end
 
@@ -231,7 +232,7 @@ class TestSnippets < Test::Unit::TestCase
         assert_nothing_raised {
             trans.rollback
         }
-        assert(! FileTest.exists?(file))
+        assert(! FileTest.exists?(file), "%s still exists" % file)
     end
 
     def snippet_argumentdefaults(trans)
@@ -433,10 +434,45 @@ class TestSnippets < Test::Unit::TestCase
         @@tmpfiles << "/tmp/settestingness"
     end
 
+    # Make sure that set tags are correctly in place, yo.
+    def snippet_tagged(trans)
+        tags = {"testing" => true, "yayness" => false,
+            "both" => false, "bothtrue" => true, "define" => true}
+
+        tags.each do |tag, retval|
+            @@tmpfiles << "/tmp/tagged#{tag}true"
+            @@tmpfiles << "/tmp/tagged#{tag}false"
+
+            assert(FileTest.exists?("/tmp/tagged#{tag}#{retval.to_s}"),
+                "'tagged' did not return %s with %s" % [retval, tag])
+        end
+    end
+
+    def snippet_defineoverrides(trans)
+        file = "/tmp/defineoverrides1"
+        assert(FileTest.exists?(file), "File does not exist")
+        assert_equal(0755, filemode(file))
+    end
+
+    def snippet_deepclassheirarchy(trans)
+        5.times { |i|
+            i += 1
+            file = "/tmp/deepclassheir%s" % i
+            assert(FileTest.exists?(file), "File %s does not exist" % file)
+        }
+    end
+
     def snippet_emptyclass(trans)
         # There's nothing to check other than that it works
     end
 
+    def snippet_emptyexec(trans)
+        assert(FileTest.exists?("/tmp/emptyexectest"),
+            "Empty exec was ignored")
+
+        @@tmpfiles << "/tmp/emptyexextest"
+    end
+
     def disabled_snippet_dirchmod(trans)
         dirs = %w{a b}.collect { |letter|
             "/tmp/dirchmodtest%s" % letter
@@ -480,6 +516,18 @@ class TestSnippets < Test::Unit::TestCase
                 assert_nothing_raised {
                     client.getconfig()
                 }
+
+                client = Puppet::Client::MasterClient.new(
+                    :Master => server,
+                    :Cache => false
+                )
+
+                assert(client.local)
+                # Now do it again
+                Puppet::Type.allclear
+                assert_nothing_raised {
+                    client.getconfig()
+                }
                 trans = nil
                 assert_nothing_raised {
                     trans = client.apply()
@@ -495,16 +543,17 @@ class TestSnippets < Test::Unit::TestCase
                         assert(obj.name)
 
                         if obj.is_a?(Puppet.type(:file))
-                            @@tmpfiles << obj.name
+                            @@tmpfiles << obj[:path]
                         end
                     }
                 }
                 assert_nothing_raised {
                     self.send(mname, trans)
                 }
+
+                client.clear
             }
             mname = mname.intern
-            #eval("alias %s %s" % [testname, mname])
         end
     }
 end

data/test/language/transportable.rb

@@ -13,34 +13,10 @@ require 'puppettest'
 require 'yaml'
 
 class TestTransportable < Test::Unit::TestCase
-	include TestPuppet
-
-    def mkobj(file = "/etc/passwd")
-        obj = nil
-        assert_nothing_raised {
-            obj = Puppet::TransObject.new("file", file)
-            obj["owner"] = "root"
-            obj["mode"] = "644"
-        }
-
-        return obj
-    end
-
-    def mkbucket(*objects)
-        bucket = nil
-        assert_nothing_raised {
-            bucket = Puppet::TransBucket.new
-            bucket.name = "yayname"
-            bucket.type = "yaytype"
-        }
-
-        objects.each { |o| bucket << o }
-
-        return bucket
-    end
+	include ParserTesting
 
     def test_yamldumpobject
-        obj = mkobj
+        obj = mk_transobject
         obj.to_yaml_properties
         str = nil
         assert_nothing_raised {
@@ -58,9 +34,9 @@ class TestTransportable < Test::Unit::TestCase
 
     def test_yamldumpbucket
         objects = %w{/etc/passwd /etc /tmp /var /dev}.collect { |d|
-            mkobj(d)
+            mk_transobject(d)
         }
-        bucket = mkbucket(*objects)
+        bucket = mk_transbucket(*objects)
         str = nil
         assert_nothing_raised {
             str = YAML.dump(bucket)
@@ -74,4 +50,60 @@ class TestTransportable < Test::Unit::TestCase
         assert(newobj.name, "Bucket has no name")
         assert(newobj.type, "Bucket has no type")
     end
+
+    # Verify that we correctly strip out collectable objects, since they should
+    # not be sent to the client.
+    def test_collectstrip
+        top = mk_transtree do |object, depth, width|
+            if width % 2 == 1
+                object.collectable = true
+            end
+        end
+
+        assert(top.flatten.find_all { |o| o.collectable }.length > 0,
+            "Could not find any collectable objects")
+
+        # Now strip out the collectable objects
+        top.collectstrip!
+
+        # And make sure they're actually gone
+        assert_equal(0, top.flatten.find_all { |o| o.collectable }.length,
+            "Still found collectable objects")
+    end
+
+    # Make sure our 'delve' command is working
+    def test_delve
+        top = mk_transtree do |object, depth, width|
+            if width % 2 == 1
+                object.collectable = true
+            end
+        end
+
+        objects = []
+        buckets = []
+        collectable = []
+
+        count = 0
+        assert_nothing_raised {
+            top.delve do |object|
+                count += 1
+                if object.is_a? Puppet::TransBucket
+                    buckets << object
+                else
+                    objects << object
+                    if object.collectable
+                        collectable << object
+                    end
+                end
+            end
+        }
+
+        top.flatten.each do |obj|
+            assert(objects.include?(obj), "Missing obj %s[%s]" % [obj.type, obj.name])
+        end
+
+        assert_equal(collectable.length,
+            top.flatten.find_all { |o| o.collectable }.length,
+            "Found incorrect number of collectable objects")
+    end
 end

data/test/other/config.rb

@@ -594,6 +594,219 @@ yay = /a/path
             end
         end
     end
+
+    def test_booleans_and_integers
+        config = mkconfig
+        config.setdefaults(:mysection,
+            :booltest => [false, "yay"],
+            :inttest => [14, "yay"]
+        )
+
+        file = tempfile()
+
+        File.open(file, "w") do |f|
+            f.puts %{
+[mysection]
+booltest = true
+inttest = 27
+}
+        end
+
+        assert_nothing_raised {
+            config.parse(file)
+        }
+
+        assert_equal(true, config[:booltest], "Boolean was not converted")
+        assert_equal(27, config[:inttest], "Integer was not converted")
+
+        # Now make sure that they get converted through handlearg
+        config.handlearg("--inttest", "true")
+        assert_equal(true, config[:inttest], "Boolean was not converted")
+        config.handlearg("--no-booltest", "false")
+        assert_equal(false, config[:booltest], "Boolean was not converted")
+    end
+
+    # Make sure that tags are ignored when configuring
+    def test_configs_ignore_tags
+        config = mkconfig
+        file = tempfile()
+
+        config.setdefaults(:mysection,
+            :mydir => [file, "a file"]
+        )
+
+        Puppet[:tags] = "yayness"
+
+        assert_nothing_raised {
+            config.use(:mysection)
+        }
+
+        assert(FileTest.directory?(file), "Directory did not get created")
+
+        assert_equal("yayness", Puppet[:tags],
+            "Tags got changed during config")
+    end
+
+    def test_configs_replace_in_url
+        config = mkconfig
+        
+        config.setdefaults(:mysection, :name => ["yayness", "yay"])
+        config.setdefaults(:mysection, :url => ["http://$name/rahness", "yay"])
+
+        val = nil
+        assert_nothing_raised {
+            val = config[:url]
+        }
+
+        assert_equal("http://yayness/rahness", val,
+            "Config got messed up")
+    end
+
+    def test_correct_type_assumptions
+        config = mkconfig
+
+        file = Puppet::Config::CFile
+        element = Puppet::Config::CElement
+        bool = Puppet::Config::CBoolean
+
+        # We have to keep these ordered, unfortunately.
+        [
+            ["/this/is/a/file", file],
+            ["true", bool],
+            [true, bool],
+            ["false", bool],
+            ["server", element],
+            ["http://$server/yay", element],
+            ["$server/yayness", file],
+            ["$server/yayness.conf", file]
+        ].each do |ary|
+            value, type = ary
+            elem = nil
+            assert_nothing_raised {
+                elem = config.newelement(
+                    :name => value,
+                    :default => value,
+                    :section => :yayness
+                )
+            }
+
+            assert_instance_of(type, elem,
+                "%s got created as wrong type" % value.inspect)
+        end
+    end
+
+    # Make sure we correctly reparse our config files but don't lose CLI values.
+    def test_reparse
+        Puppet[:filetimeout] = 0
+
+        config = mkconfig()
+        config.setdefaults(:mysection, :default => ["default", "yay"])
+        config.setdefaults(:mysection, :clichange => ["clichange", "yay"])
+        config.setdefaults(:mysection, :filechange => ["filechange", "yay"])
+
+        file = tempfile()
+        # Set one parameter in the file
+        File.open(file, "w") { |f|
+            f.puts %{[mysection]\nfilechange = filevalue}
+        }
+        assert_nothing_raised {
+            config.parse(file)
+        }
+
+        # Set another "from the cli"
+        assert_nothing_raised {
+            config.handlearg("clichange", "clivalue")
+        }
+
+        # And leave the other unset
+        assert_equal("default", config[:default])
+        assert_equal("filevalue", config[:filechange])
+        assert_equal("clivalue", config[:clichange])
+
+        # Now rewrite the file
+        File.open(file, "w") { |f|
+            f.puts %{[mysection]\nfilechange = newvalue}
+        }
+
+        cfile = config.file
+        cfile.send("tstamp=".intern, Time.now - 50)
+
+        # And check all of the values
+        assert_equal("default", config[:default])
+        assert_equal("clivalue", config[:clichange])
+        assert_equal("newvalue", config[:filechange])
+    end
+
+    def test_parse_removes_quotes
+        config = mkconfig()
+        config.setdefaults(:mysection, :singleq => ["single", "yay"])
+        config.setdefaults(:mysection, :doubleq => ["double", "yay"])
+        config.setdefaults(:mysection, :none => ["noquote", "yay"])
+        config.setdefaults(:mysection, :middle => ["midquote", "yay"])
+
+        file = tempfile()
+        # Set one parameter in the file
+        File.open(file, "w") { |f|
+            f.puts %{[mysection]\n
+    singleq = 'one'
+    doubleq = "one"
+    none = one
+    middle = mid"quote
+}
+        }
+
+        assert_nothing_raised {
+            config.parse(file)
+        }
+
+        %w{singleq doubleq none}.each do |p|
+            assert_equal("one", config[p], "%s did not match" % p)
+        end
+        assert_equal('mid"quote', config["middle"], "middle did not match")
+    end
+
+    def test_timer
+        Puppet[:filetimeout] = 0.1
+        origpath = tempfile()
+        config = mkconfig()
+        config.setdefaults(:mysection, :paramdir => [tempfile(), "yay"])
+
+        file = tempfile()
+        # Set one parameter in the file
+        File.open(file, "w") { |f|
+            f.puts %{[mysection]\n
+    paramdir = #{origpath}
+}
+        }
+
+        assert_nothing_raised {
+            config.parse(file)
+            config.use(:mysection)
+        }
+
+        assert(FileTest.directory?(origpath), "dir did not get created")
+
+        # Now start the timer
+        assert_nothing_raised {
+            EventLoop.current.monitor_timer config.timer
+        }
+
+        newpath = tempfile()
+
+        File.open(file, "w") { |f|
+            f.puts %{[mysection]\n
+    paramdir = #{newpath}
+}
+        }
+        config.file.send("tstamp=".intern, Time.now - 50)
+        sleep 1
+
+        assert_equal(newpath, config["paramdir"],
+                    "File did not get reparsed from timer")
+        assert(FileTest.directory?(newpath), "new dir did not get created")
+
+
+    end
 end
 
-# $Id: config.rb 1077 2006-04-05 06:53:12Z luke $
+# $Id: config.rb 1420 2006-07-21 21:16:09Z luke $

data/test/other/events.rb

@@ -8,7 +8,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: events.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: events.rb 1179 2006-05-05 19:47:15Z luke $
 
 class TestEvents < Test::Unit::TestCase
 	include TestPuppet
@@ -66,6 +66,8 @@ class TestEvents < Test::Unit::TestCase
         assert_equal(0, trans.triggered?(exec, :refresh))
     end
 
+    # Verify that one component can subscribe to another component and the "right"
+    # thing happens
     def test_ladderrequire
         comps = {}
         objects = {}
@@ -81,21 +83,77 @@ class TestEvents < Test::Unit::TestCase
             :refreshonly => true
         )
 
-        comps[:f] = newcomp(file)
-        comps[:e] = newcomp(exec)
+        fcomp = newcomp(file)
+        ecomp = newcomp(exec)
+        comp = newcomp("laddercomp", fcomp, ecomp)
 
-        comps[:e][:subscribe] = [[comps[:f].class.name, comps[:f].name]]
-        comps.each { |l, c|
-            c.finalize
-        }
+        ecomp[:subscribe] = [[fcomp.class.name, fcomp.name]]
+
+        comp.finalize
 
-        trans = comps[:f].evaluate
+        trans = comp.evaluate
         events = nil
         assert_nothing_raised {
             events = trans.evaluate
         }
 
-        assert(FileTest.exists?(fname))
+        assert(FileTest.exists?(fname), "#{fname} does not exist")
         #assert_equal(events.length, trans.triggered?(objects[:b], :refresh))
     end
+
+    def test_multiplerefreshes
+        files = []
+
+        4.times { |i|
+            files << Puppet.type(:file).create(
+                :name => tempfile(),
+                :ensure => "file"
+            )
+        }
+
+        fname = tempfile()
+        exec = Puppet.type(:exec).create(
+            :name => "touch %s" % fname,
+            :path => "/usr/bin:/bin",
+            :refreshonly => true
+        )
+
+        exec[:subscribe] = files.collect { |f|
+            ["file", f.name]
+        }
+
+        comp = newcomp(exec, *files)
+
+        assert_apply(comp)
+        assert(FileTest.exists?(fname), "Exec file did not get created")
+    end
+
+    def test_refreshordering
+        file = tempfile()
+
+        exec1 = Puppet.type(:exec).create(
+            :name => "echo one >> %s" % file,
+            :path => "/usr/bin:/bin"
+        )
+
+        exec2 = Puppet.type(:exec).create(
+            :name => "echo two >> %s" % file,
+            :path => "/usr/bin:/bin",
+            :refreshonly => true,
+            :subscribe => ["exec", exec1.name]
+        )
+
+        exec3 = Puppet.type(:exec).create(
+            :name => "echo three >> %s" % file,
+            :path => "/usr/bin:/bin"
+        )
+
+        comp = newcomp(exec1,exec2,exec3)
+
+        assert_apply(comp)
+
+        assert(FileTest.exists?(file), "File does not exist")
+
+        assert_equal("one\ntwo\nthree\n", File.read(file))
+    end
 end