puppet 0.9.2 → 0.13.0

data/test/language/ast.rb

@@ -172,6 +172,10 @@ class TestAST < Test::Unit::TestCase
         scope = nil
         assert_nothing_raised("Could not evaluate node") {
             scope = Puppet::Parser::Scope.new()
+            scope.name = "nodetest"
+            scope.type = "nodetest"
+            scope.keyword = "nodetest"
+            scope.top = true
             top.evaluate(scope)
         }
 
@@ -289,11 +293,11 @@ class TestAST < Test::Unit::TestCase
 
         # And now verify that we got both the top and node objects
         assert_nothing_raised("Could not find top-declared object") {
-            assert_equal("/testing", objects[0][:name])
+            assert_equal("/testing", objects[0]["name"])
         }
 
         assert_nothing_raised("Could not find node-declared object") {
-            assert_equal("/%s" % name, objects[1][0][:name])
+            assert_equal("/%s" % name, objects[1][0]["name"])
         }
     end
 
@@ -334,12 +338,12 @@ class TestAST < Test::Unit::TestCase
         assert(objects, "Could not retrieve objects")
 
         assert_nothing_raised("Could not find top-declared object") {
-            assert_equal("/%s" % klassname, objects[0][0][:name])
+            assert_equal("/%s" % klassname, objects[0][0]["name"])
         }
     end
 
     # Test that node inheritance works correctly
-    def test_znodeinheritance
+    def test_nodeinheritance
         children = []
 
         # create the base node
@@ -391,19 +395,19 @@ class TestAST < Test::Unit::TestCase
             # And now verify that we got the subnode file
             assert_nothing_raised("Could not find basenode file") {
                 base = inner[0]
-                assert_equal("/basenode", base[:name])
+                assert_equal("/basenode", base["name"])
             }
 
             # and the parent node file
             assert_nothing_raised("Could not find subnode file") {
                 sub = inner[1]
-                assert_equal("/subnode", sub[:name])
+                assert_equal("/subnode", sub["name"])
             }
 
             inner.each { |obj|
                 %w{basenode subnode}.each { |tag|
                     assert(obj.tags.include?(tag),
-                        "%s did not include %s tag" % [obj[:name], tag]
+                        "%s did not include %s tag" % [obj["name"], tag]
                     )
                 }
             }

data/test/language/interpreter.rb

@@ -22,7 +22,7 @@ class TestInterpreter < Test::Unit::TestCase
         createdfile = tempfile()
 
         File.open(file, "w") { |f|
-            f.puts "node %s { file { \"%s\": create => true, mode => 755 } }\n" %
+            f.puts "node %s { file { \"%s\": ensure => file, mode => 755 } }\n" %
                 [node, createdfile]
         }
 

data/test/language/scope.rb

@@ -396,6 +396,8 @@ class TestScope < Test::Unit::TestCase
         scope = nil
         assert_nothing_raised("Could not evaluate") {
             scope = Puppet::Parser::Scope.new()
+            scope.name =  "topscope"
+            scope.type =  "topscope"
             objects = scope.evaluate(top)
         }
 

data/test/language/snippets.rb

@@ -159,7 +159,7 @@ class TestSnippets < Test::Unit::TestCase
         %w{a b c d}.each { |letter|
             file = "/tmp/create%stest" % letter
             Puppet.info "testing %s" % file
-            assert(Puppet::Type::PFile[file], "File %s does not exist" % file)
+            assert(Puppet.type(:file)[file], "File %s does not exist" % file)
             assert(FileTest.exists?(file))
             @@tmpfiles << file
         }
@@ -196,8 +196,9 @@ class TestSnippets < Test::Unit::TestCase
         @@tmpfiles += files
 
         files.each { |file|
-            assert(FileTest.exists?(file))
-            assert(File.stat(file).mode & 007777 == 0755)
+            assert(FileTest.exists?(file), "File %s does not exist" % file)
+            assert(File.stat(file).mode & 007777 == 0755,
+                "File %s is the incorrect mode" % file)
             @@tmpfiles << file
         }
 
@@ -217,7 +218,7 @@ class TestSnippets < Test::Unit::TestCase
 
         obj = nil
         assert_nothing_raised {
-            obj = Puppet::Type::PFile[file]
+            obj = Puppet.type(:file)[file]
         }
 
         assert_nothing_raised {
@@ -251,6 +252,7 @@ class TestSnippets < Test::Unit::TestCase
             /tmp/existsfile
             /tmp/existsfile2
             /tmp/existsfile3
+            /tmp/existsfile4
         }
 
         files.each { |file|
@@ -368,6 +370,14 @@ class TestSnippets < Test::Unit::TestCase
         }
     end
 
+    def snippet_singleary(trans)
+        [1,2,3,4].each { |num|
+            file = "/tmp/singleary%s" % num
+            @@tmpfiles << file
+            assert(FileTest.file?(file), "File %s does not exist" % file)
+        }
+    end
+
     def snippet_classincludes(trans)
         [1,2,3].each { |num|
             file = "/tmp/classincludes%s" % num
@@ -378,6 +388,16 @@ class TestSnippets < Test::Unit::TestCase
         }
     end
 
+    def snippet_componentmetaparams(trans)
+        ["/tmp/component1", "/tmp/component2"].each { |file|
+            assert(FileTest.file?(file), "File %s does not exist" % file)
+        }
+    end
+
+    def snippet_emptyclass(trans)
+        # There's nothing to check other than that it works
+    end
+
     def disabled_snippet_dirchmod(trans)
         dirs = %w{a b}.collect { |letter|
             "/tmp/dirchmodtest%s" % letter
@@ -428,10 +448,15 @@ class TestSnippets < Test::Unit::TestCase
 
                 Puppet::Type.eachtype { |type|
                     type.each { |obj|
-                        unless obj.name == "puppet[top]"
+                        unless obj.name == "puppet[top]" or
+                            obj.is_a?(Puppet.type(:schedule))
                             assert(obj.parent, "%s has no parent" % obj.name)
                         end
                         assert(obj.name)
+
+                        if obj.is_a?(Puppet.type(:file))
+                            @@tmpfiles << obj.name
+                        end
                     }
                 }
                 assert_nothing_raised {

data/test/language/transportable.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/ruby
+
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/transportable'
+require 'test/unit'
+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
+
+    def test_yamldumpobject
+        obj = mkobj
+        obj.to_yaml_properties
+        str = nil
+        assert_nothing_raised {
+            str = YAML.dump(obj)
+        }
+
+        newobj = nil
+        assert_nothing_raised {
+            newobj = YAML.load(str)
+        }
+
+        assert(newobj.name, "Object has no name")
+        assert(newobj.type, "Object has no type")
+    end
+
+    def test_yamldumpbucket
+        objects = %w{/etc/passwd /etc /tmp /var /dev}.collect { |d|
+            mkobj(d)
+        }
+        bucket = mkbucket(*objects)
+        str = nil
+        assert_nothing_raised {
+            str = YAML.dump(bucket)
+        }
+
+        newobj = nil
+        assert_nothing_raised {
+            newobj = YAML.load(str)
+        }
+
+        assert(newobj.name, "Bucket has no name")
+        assert(newobj.type, "Bucket has no type")
+    end
+end

data/test/other/config.rb

@@ -0,0 +1,316 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/config'
+require 'puppettest'
+require 'test/unit'
+
+class TestConfig < Test::Unit::TestCase
+	include TestPuppet
+
+    def check_to_transportable(config)
+        trans = nil
+        assert_nothing_raised("Could not convert to a transportable") {
+            trans = config.to_transportable
+        }
+
+        comp = nil
+        assert_nothing_raised("Could not convert transportable to component") {
+            comp = trans.to_type
+        }
+
+        assert_nothing_raised("Could not retrieve transported config") {
+            comp.retrieve
+        }
+    end
+
+    def check_to_manifest(config)
+        manifest = nil
+        assert_nothing_raised("Could not convert to a manifest") {
+            manifest = config.to_manifest
+        }
+
+        Puppet[:parseonly] = true
+        parser = Puppet::Parser::Parser.new()
+
+        assert_nothing_raised("Could not parse generated manifest") {
+            parser.string = manifest
+            parser.parse
+        }
+    end
+
+    def check_to_comp(config)
+        comp = nil
+        assert_nothing_raised("Could not convert to a component") {
+            comp = config.to_component
+        }
+
+        assert_nothing_raised("Could not retrieve component") {
+            comp.retrieve
+        }
+    end
+
+    def check_to_config(config)
+        newc = config.dup
+
+        newfile = tempfile()
+        File.open(newfile, "w") { |f| f.print config.to_config }
+        assert_nothing_raised("Could not parse generated configuration") {
+            newc.parse(newfile)
+        }
+
+        assert_equal(config, newc, "Configurations are not equal")
+    end
+
+    def mkconfig
+        c = nil
+        assert_nothing_raised {
+            c = Puppet::Config.new
+        }
+        return c
+    end
+
+    def test_addbools
+        c = mkconfig
+
+        assert_nothing_raised {
+            c.setdefaults(:testing, [:booltest, true, "testing"])
+        }
+
+        assert(c[:booltest])
+        c = mkconfig
+
+        assert_nothing_raised {
+            c.setdefaults(:testing, [:booltest, "true", "testing"])
+        }
+
+        assert(c[:booltest])
+
+        assert_nothing_raised {
+            c[:booltest] = false
+        }
+
+        assert(! c[:booltest], "Booltest is not false")
+
+        assert_nothing_raised {
+            c[:booltest] = "false"
+        }
+
+        assert(! c[:booltest], "Booltest is not false")
+
+        assert_raise(Puppet::Error) {
+            c[:booltest] = "yayness"
+        }
+
+        assert_raise(Puppet::Error) {
+            c[:booltest] = "/some/file"
+        }
+    end
+
+    def test_strings
+        c = mkconfig
+        val = "this is a string"
+        assert_nothing_raised {
+            c.setdefaults(:testing, [:strtest, val, "testing"])
+        }
+
+        assert_equal(val, c[:strtest])
+    end
+
+    def test_files
+        c = mkconfig
+
+        parent = "/puppet"
+        assert_nothing_raised {
+            c.setdefaults(:testing, [:parentdir, parent, "booh"])
+        }
+
+        assert_nothing_raised {
+            c.setdefaults(:testing, [:child, "$parent/child", "rah"])
+        }
+
+        assert_equal(parent, c[:parentdir])
+        assert_equal("/puppet/child", File.join(c[:parentdir], "child"))
+    end
+
+    def test_getset
+        c = mkconfig
+        initial = "an initial value"
+        assert_raise(Puppet::Error) {
+            c[:yayness] = initial
+        }
+
+        default = "this is a default"
+        assert_nothing_raised {
+            c.setdefaults(:testing, [:yayness, default, "rah"])
+        }
+
+        assert_equal(default, c[:yayness])
+
+        assert_nothing_raised {
+            c[:yayness] = initial
+        }
+
+        assert_equal(initial, c[:yayness])
+
+        assert_nothing_raised {
+            c.clear
+        }
+
+        assert_equal(default, c[:yayness])
+
+        assert_nothing_raised {
+            c[:yayness] = "not default"
+        }
+        assert_equal("not default", c[:yayness])
+    end
+
+    def test_parse
+        text = %{
+one = this is a test
+two = another test
+owner = root
+group = root
+yay = /a/path
+
+[section1]
+    attr = value
+    owner = puppet
+    group = puppet
+    attrdir = /some/dir
+    attr3 = $attrdir/other
+        }
+
+        file = tempfile()
+        File.open(file, "w") { |f| f.puts text }
+
+        c = mkconfig
+        assert_nothing_raised {
+            c.setdefaults("puppet",
+                [:one, "a", "one"],
+                [:two, "a", "two"],
+                [:yay, "/default/path", "boo"]
+            )
+        }
+
+        assert_nothing_raised {
+            c.setdefaults("section1",
+                [:attr, "a", "one"],
+                [:attrdir, "/another/dir", "two"],
+                [:attr3, "$attrdir/maybe", "boo"]
+            )
+        }
+        
+        assert_nothing_raised {
+            c.parse(file)
+        }
+
+        assert_equal("value", c[:attr])
+        assert_equal("/some/dir", c[:attrdir])
+        assert_equal(:directory, c.element(:attrdir).type)
+        assert_equal("/some/dir/other", c[:attr3])
+
+        elem = nil
+        assert_nothing_raised {
+            elem = c.element(:attr3)
+        }
+
+        assert(elem)
+        assert_equal("puppet", elem.owner)
+
+        config = nil
+        assert_nothing_raised {
+            config = c.to_config
+        }
+
+        assert_nothing_raised("Could not create transportable config") {
+            c.to_transportable
+        }
+
+        check_to_comp(c)
+        Puppet::Type.allclear
+        check_to_manifest(c)
+        Puppet::Type.allclear
+        check_to_config(c)
+        Puppet::Type.allclear
+        check_to_transportable(c)
+    end
+
+    def test_arghandling
+        c = mkconfig
+
+        assert_nothing_raised {
+            c.setdefaults("testing",
+                [:onboolean, true, "An on bool"],
+                [:offboolean, false, "An off bool"],
+                [:string, "a string", "A string arg"],
+                [:file, "/path/to/file", "A file arg"]
+            )
+        }
+
+        data = {
+            :onboolean => [true, false],
+            :offboolean => [true, false],
+            :string => ["one string", "another string"],
+            :file => %w{/a/file /another/file}
+        }
+        data.each { |param, values|
+            values.each { |val|
+                opt = nil
+                arg = nil
+                if c.boolean?(param)
+                    if val
+                        opt = "--%s" % param
+                    else
+                        opt = "--no-%s" % param
+                    end
+                else
+                    opt = "--%s" % param
+                    arg = val
+                end
+
+                assert_nothing_raised("Could not handle arg %s with value %s" %
+                    [opt, val]) {
+
+                    c.handlearg(opt, arg)
+                }
+            }
+        }
+    end
+
+    def test_argadding
+        c = mkconfig
+
+        assert_nothing_raised {
+            c.setdefaults("testing",
+                [:onboolean, true, "An on bool"],
+                [:offboolean, false, "An off bool"],
+                [:string, "a string", "A string arg"],
+                [:file, "/path/to/file", "A file arg"]
+            )
+        }
+        options = []
+
+        c.addargs(options)
+
+        c.each { |param, obj|
+            opt = "--%s" % param
+            assert(options.find { |ary|
+                ary[0] == opt
+            }, "Argument %s was not added" % opt)
+
+            if c.boolean?(param)
+                o = "--no-%s" % param
+                assert(options.find { |ary|
+                ary[0] == o
+                }, "Boolean off %s was not added" % o)
+            end
+        }
+    end
+end
+
+# $Id: config.rb 873 2006-02-07 23:12:33Z luke $