puppet 0.13.6 → 0.16.0

data/test/language/interpreter.rb

@@ -6,6 +6,8 @@ if __FILE__ == $0
     $puppetbase = "../.."
 end
 
+require 'facter'
+
 require 'puppet'
 require 'puppet/parser/interpreter'
 require 'puppet/parser/parser'
@@ -69,8 +71,6 @@ class TestInterpreter < Test::Unit::TestCase
         assert(config != newconfig, "Configs are somehow the same")
     end
 
-    # Only test ldap stuff on luke's network, since that's the only place we
-    # have data for.
     if Facter["domain"].value == "madstop.com"
     begin
         require 'ldap'
@@ -79,6 +79,9 @@ class TestInterpreter < Test::Unit::TestCase
         $stderr.puts "Missing ldap; skipping ldap source tests"
         $haveldap = false
     end
+
+    # Only test ldap stuff on luke's network, since that's the only place we
+    # have data for.
     if $haveldap
     def ldapconnect
 
@@ -112,6 +115,7 @@ class TestInterpreter < Test::Unit::TestCase
         files << parentfile
         hostname = Facter["hostname"].value
         lparent, lclasses = ldaphost(Facter["hostname"].value)
+        assert(lclasses, "Did not retrieve info from ldap")
         File.open(file, "w") { |f|
             f.puts "node #{lparent} {
     file { \"#{parentfile}\": ensure => file }
@@ -161,5 +165,7 @@ class TestInterpreter < Test::Unit::TestCase
         }
     end
     end
+    else
+        $stderr.puts "Not in madstop.com; skipping ldap tests"
     end
 end

data/test/{parser → language}/lexer.rb

@@ -125,4 +125,4 @@ class TestLexer < Test::Unit::TestCase
     end
 end
 
-# $Id: lexer.rb 923 2006-02-16 20:15:41Z luke $
+# $Id: lexer.rb 1070 2006-04-04 23:30:56Z luke $

data/test/language/node.rb

@@ -0,0 +1,84 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/parser/parser'
+require 'test/unit'
+require 'puppettest'
+
+class TestParser < Test::Unit::TestCase
+	include ParserTesting
+
+    def setup
+        super
+        Puppet[:parseonly] = true
+        @parser = Puppet::Parser::Parser.new()
+    end
+
+    def test_simple_hostname
+        check_parseable "host1"
+        check_parseable "'host2'"
+        check_parseable [ "'host1'",  "host2" ]
+        check_parseable [ "'host1'",  "'host2'" ]
+    end
+
+    def test_qualified_hostname
+        check_parseable "'host.example.com'"
+        check_parseable [ "'host.example.com'", "host1" ]
+        check_parseable "'host-1.37examples.example.com'"
+        check_parseable "'svn.23.nu'"
+        check_parseable "'HOST'"
+    end
+
+    def test_reject_hostname
+        check_nonparseable "host.example.com"
+        check_nonparseable "host@example.com"
+        check_nonparseable "\"host\""
+        check_nonparseable "'$foo.example.com'"
+        check_nonparseable "'host1 host2'"
+        check_nonparseable "HOST"
+    end
+
+    AST = Puppet::Parser::AST
+
+    def check_parseable(hostnames)
+        unless hostnames.is_a?(Array)
+            hostnames = [ hostnames ]
+        end
+        assert_nothing_raised {
+            @parser.string = "node #{hostnames.join(" ")} { }"
+        }
+        # Strip quotes
+        hostnames.map! { |s| s.sub(/^'(.*)'$/, "\\1") }
+        ast = nil
+        assert_nothing_raised {
+            ast = @parser.parse
+        }
+        # Verify that the AST has the expected structure
+        # and that the leaves have the right hostnames in them
+        assert_kind_of(AST::ASTArray, ast)
+        assert_equal(1, ast.children.size)
+        nodedef = ast.children[0]
+        assert_kind_of(AST::NodeDef, nodedef)
+        assert_kind_of(AST::ASTArray, nodedef.names)
+        assert_equal(hostnames.size, nodedef.names.children.size)
+        hostnames.size.times do |i|
+            hostnode = nodedef.names.children[i]
+            assert_kind_of(AST::HostName, hostnode)
+            assert_equal(hostnames[i], hostnode.value)
+        end
+    end
+
+    def check_nonparseable(hostname)
+        assert_nothing_raised {
+            @parser.string = "node #{hostname} { }"
+        }
+
+        assert_raise(Puppet::DevError, Puppet::ParseError) {
+            @parser.parse
+        }
+    end
+end

data/test/{parser → language}/parser.rb

@@ -209,4 +209,4 @@ class TestParser < Test::Unit::TestCase
     end
 end
 
-# $Id: parser.rb 957 2006-02-28 03:32:51Z luke $
+# $Id: parser.rb 1070 2006-04-04 23:30:56Z luke $

data/test/language/scope.rb

@@ -88,9 +88,11 @@ class TestScope < Test::Unit::TestCase
 
                 # verify that they aren't available in upper scopes
                 if parent = s.parent
-                    assert_raise(Puppet::ParseError) {
-                        parent.lookupvar(v)
+                    val = nil
+                    assert_nothing_raised {
+                        val = parent.lookupvar(v)
                     }
+                    assert_equal("", val, "Did not get empty string on missing var")
 
                     # and verify that the parent sees its correct value
                     assert_equal(ovalues[i - 1],parent.lookupvar(over))
@@ -464,4 +466,101 @@ class TestScope < Test::Unit::TestCase
             objects = top.evaluate(:scope => scope)
         }
     end
+
+    # Verify that definitions have a different context than classes.
+    def test_newsubcontext
+        filename = tempfile()
+        children = []
+
+        # Create a component
+        children << compobj("comp", :code => AST::ASTArray.new(
+            :children => [
+                fileobj(filename, "owner" => "root" )
+            ]
+        ))
+
+        # Now create a class that modifies the same file and also
+        # calls the component
+        children << classobj("klass", :code => AST::ASTArray.new(
+            :children => [
+                fileobj(filename, "owner" => "bin" ),
+                AST::ObjectDef.new(
+                    :type => nameobj("comp"),
+                    :params => astarray()
+                )
+            ]
+        ))
+
+        # Now call the class
+        children << AST::ObjectDef.new(
+            :type => nameobj("klass"),
+            :params => astarray()
+        )
+
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        trans = nil
+        scope = nil
+        #assert_nothing_raised {
+        assert_raise(Puppet::ParseError, "A conflict was allowed") {
+            scope = Puppet::Parser::Scope.new()
+            trans = scope.evaluate(:ast => top)
+        }
+        #    scope = Puppet::Parser::Scope.new()
+        #    trans = scope.evaluate(:ast => top)
+        #}
+    end
+
+    def test_defaultswithmultiplestatements
+        path = tempfile()
+
+        stats = []
+        stats << defaultobj("file", "group" => "root")
+        stats << fileobj(path, "owner" => "root")
+        stats << fileobj(path, "mode" => "755")
+
+        top = AST::ASTArray.new(
+            :file => __FILE__,
+            :line => __LINE__,
+            :children => stats
+        )
+        scope = Puppet::Parser::Scope.new()
+        assert_nothing_raised {
+            scope.evaluate(:ast => top)
+        }
+
+        trans = nil
+        assert_nothing_raised {
+            trans = scope.to_trans
+        }
+
+        obj = trans.find do |obj| obj.is_a? Puppet::TransObject end
+
+        assert(obj, "Could not retrieve file obj")
+        assert_equal("root", obj["group"], "Default did not take")
+        assert_equal("root", obj["owner"], "Owner did not take")
+        assert_equal("755", obj["mode"], "Mode did not take")
+    end
+
+    def test_validclassnames
+        scope = Puppet::Parser::Scope.new()
+
+        ["a-class", "a class", "Class", "a.class"].each do |bad|
+            assert_raise(Puppet::ParseError, "Incorrectly allowed %s" % bad.inspect) do
+                scope.setclass(object_id, bad)
+            end
+        end
+
+        ["a_class", "class", "yayNess"].each do |good|
+            assert_nothing_raised("Incorrectly banned %s" % good.inspect) do
+                scope.setclass(object_id, good)
+            end
+        end
+
+    end
 end

data/test/language/snippets.rb

@@ -253,6 +253,7 @@ class TestSnippets < Test::Unit::TestCase
             /tmp/existsfile2
             /tmp/existsfile3
             /tmp/existsfile4
+            /tmp/existsfile5
         }
 
         files.each { |file|
@@ -331,7 +332,7 @@ class TestSnippets < Test::Unit::TestCase
     end
 
     def snippet_selectorvalues(trans)
-        nums = %w{1 2 3}
+        nums = %w{1 2 3 4 5}
         files = nums.collect { |n|
             "/tmp/selectorvalues%s" % n
         }
@@ -344,6 +345,20 @@ class TestSnippets < Test::Unit::TestCase
         }
     end
 
+    def snippet_singleselector(trans)
+        nums = %w{1 2 3}
+        files = nums.collect { |n|
+            "/tmp/singleselector%s" % n
+        }
+
+        files.each { |f|
+            @@tmpfiles << f
+            assert(FileTest.exists?(f), "File %s does not exist" % f)
+            assert(File.stat(f).mode & 007777 == 0755,
+                "File %s is not 755" % f)
+        }
+    end
+
     def snippet_falsevalues(trans)
         file = "/tmp/falsevaluesfalse"
         @@tmpfiles << file
@@ -412,6 +427,12 @@ class TestSnippets < Test::Unit::TestCase
         }
     end
 
+    # There's no way to actually retrieve the list of classes from the
+    # transaction.
+    def snippet_tag(trans)
+        @@tmpfiles << "/tmp/settestingness"
+    end
+
     def snippet_emptyclass(trans)
         # There's nothing to check other than that it works
     end
@@ -447,7 +468,7 @@ class TestSnippets < Test::Unit::TestCase
             self.send(:define_method, testname) {
                 # first parse the file
                 server = Puppet::Server::Master.new(
-                    :File => File.join($snippetbase, file),
+                    :Manifest => File.join($snippetbase, file),
                     :Local => true
                 )
                 client = Puppet::Client::MasterClient.new(

data/test/other/config.rb

@@ -496,6 +496,104 @@ yay = /a/path
 
         assert(! Puppet.type(:file)["/dev/testing"], "Created dev file")
     end
+
+    def test_groupsetting
+        cfile = tempfile()
+
+        group = "yayness"
+
+        File.open(cfile, "w") do |f|
+            f.puts "[#{Puppet.name}]
+            group = #{group}
+            "
+        end
+
+        config = mkconfig
+        config.setdefaults(Puppet.name, :group => ["puppet", "a group"])
+
+        assert_nothing_raised {
+            config.parse(cfile)
+        }
+
+        assert_equal(group, config[:group], "Group did not take")
+    end
+
+    # provide a method to modify and create files w/out specifying the info
+    # already stored in a config
+    def test_writingfiles
+        path = tempfile()
+        mode = 0644
+
+        config = mkconfig
+
+        args = { :default => path, :mode => mode }
+
+        user = nonrootuser()
+        group = nonrootgroup()
+
+        if Process.uid == 0
+            args[:owner] = user.name
+            args[:group] = group.name
+        end
+
+        config.setdefaults(:testing, :myfile => args)
+
+        assert_nothing_raised {
+            config.write(:myfile) do |file|
+                file.puts "yay"
+            end
+        }
+
+        assert_equal(mode, filemode(path), "Modes are not equal")
+
+        # OS X is broken in how it chgrps files 
+        if Process.uid == 0
+            assert_equal(user.uid, File.stat(path).uid, "UIDS are not equal")
+
+            case Facter["operatingsystem"].value
+            when /BSD/, "Darwin": # nothing
+            else
+                assert_equal(group.gid, File.stat(path).gid, "GIDS are not equal")
+            end
+        end
+    end
+
+    def test_mkdir
+        path = tempfile()
+        mode = 0755
+
+        config = mkconfig
+
+        args = { :default => path, :mode => mode }
+
+        user = nonrootuser()
+        group = nonrootgroup()
+
+        if Process.uid == 0
+            args[:owner] = user.name
+            args[:group] = group.name
+        end
+
+        config.setdefaults(:testing, :mydir => args)
+
+        assert_nothing_raised {
+            config.mkdir(:mydir)
+        }
+
+        assert_equal(mode, filemode(path), "Modes are not equal")
+
+
+        # OS X and *BSD is broken in how it chgrps files 
+        if Process.uid == 0
+            assert_equal(user.uid, File.stat(path).uid, "UIDS are not equal")
+
+            case Facter["operatingsystem"].value
+            when /BSD/, "Darwin": # nothing
+            else
+                assert_equal(group.gid, File.stat(path).gid, "GIDS are not equal")
+            end
+        end
+    end
 end
 
-# $Id: config.rb 967 2006-03-02 20:28:45Z luke $
+# $Id: config.rb 1077 2006-04-05 06:53:12Z luke $

data/test/other/filetype.rb

@@ -0,0 +1,95 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/filetype'
+require 'puppettest'
+require 'test/unit'
+
+class TestFileType < Test::Unit::TestCase
+	include TestPuppet
+
+    def test_flat
+        obj = nil
+        path = tempfile()
+        type = nil
+
+        assert_nothing_raised {
+            type = Puppet::FileType.filetype(:flat)
+        }
+
+        assert(type, "Could not retrieve flat filetype")
+
+        assert_nothing_raised {
+            obj = type.new(path)
+        }
+
+        text = "This is some text\n"
+
+        newtext = nil
+        assert_nothing_raised {
+            newtext = obj.read
+        }
+
+        # The base class doesn't allow a return of nil
+        assert_equal("", newtext, "Somehow got some text")
+
+        assert_nothing_raised {
+            obj.write(text)
+        }
+        assert_nothing_raised {
+            newtext = obj.read
+        }
+
+        assert_equal(text, newtext, "Text was changed somehow")
+
+        File.open(path, "w") { |f| f.puts "someyayness" }
+
+        text = File.read(path)
+        assert_nothing_raised {
+            newtext = obj.read
+        }
+
+        assert_equal(text, newtext, "Text was changed somehow")
+    end
+
+    if Facter["operatingsystem"].value == "Darwin"
+    def test_ninfotoarray
+        obj = nil
+        type = nil
+
+        assert_nothing_raised {
+            type = Puppet::FileType.filetype(:netinfo)
+        }
+
+        assert(type, "Could not retrieve netinfo filetype")
+        %w{users groups aliases}.each do |map|
+            assert_nothing_raised {
+                obj = type.new(map)
+            }
+
+            assert_nothing_raised("could not read map %s" % map) {
+                obj.read
+            }
+
+            array = nil
+
+            assert_nothing_raised {
+                array = obj.to_array
+            }
+
+            assert_instance_of(Array, array)
+
+            array.each do |record|
+                assert_instance_of(Hash, record)
+                assert(record.length != 0)
+            end
+        end
+    end
+    end
+end
+
+# $Id: filetype.rb 1068 2006-04-04 23:13:55Z luke $