puppet 0.16.0 → 0.18.4

data/test/language/interpreter.rb

@@ -12,11 +12,13 @@ require 'puppet'
 require 'puppet/parser/interpreter'
 require 'puppet/parser/parser'
 require 'puppet/client'
+require 'puppet/rails'
 require 'test/unit'
 require 'puppettest'
 
 class TestInterpreter < Test::Unit::TestCase
 	include TestPuppet
+	include ServerTest
     AST = Puppet::Parser::AST
 
     # create a simple manifest that uses nodes to create a file
@@ -71,6 +73,41 @@ class TestInterpreter < Test::Unit::TestCase
         assert(config != newconfig, "Configs are somehow the same")
     end
 
+    if defined? ActiveRecord
+    def test_hoststorage
+        assert_nothing_raised {
+            Puppet[:storeconfigs] = true
+        }
+
+        file = tempfile()
+        File.open(file, "w") { |f|
+            f.puts "file { \"/etc\": owner => root }"
+        }
+
+        interp = nil
+        assert_nothing_raised {
+            interp = Puppet::Parser::Interpreter.new(
+                :Manifest => file,
+                :UseNodes => false,
+                :ForkSave => false
+            )
+        }
+
+        facts = {}
+        Facter.each { |fact, val| facts[fact] = val }
+
+        objects = nil
+        assert_nothing_raised {
+            objects = interp.run(facts["hostname"], facts)
+        }
+
+        obj = Puppet::Rails::Host.find_by_name(facts["hostname"])
+        assert(obj, "Could not find host object")
+    end
+    else
+        $stderr.puts "No ActiveRecord -- skipping collection tests"
+    end
+
     if Facter["domain"].value == "madstop.com"
     begin
         require 'ldap'
@@ -99,7 +136,7 @@ class TestInterpreter < Test::Unit::TestCase
             "(&(objectclass=puppetclient)(cn=%s))" % node
         ) do |entry|
             parent = entry.vals("parentnode").shift
-            classes = entry.vals("puppetclass")
+            classes = entry.vals("puppetclass") || []
         end
 
         return parent, classes
@@ -107,6 +144,7 @@ class TestInterpreter < Test::Unit::TestCase
 
     def test_ldapnodes
         Puppet[:ldapbase] = "ou=hosts, dc=madstop, dc=com"
+        Puppet[:ldapnodes] = true
 
         ldapconnect()
         file = tempfile()
@@ -130,17 +168,33 @@ class TestInterpreter < Test::Unit::TestCase
         interp = nil
         assert_nothing_raised {
             interp = Puppet::Parser::Interpreter.new(
-                :Manifest => file,
-                :NodeSources => [:ldap]
+                :Manifest => file
             )
         }
 
+        parent = nil
+        classes = nil
+        # First make sure we get the default node for unknown hosts
+        dparent, dclasses = ldaphost("default")
+
+        assert_nothing_raised {
+            parent, classes = interp.nodesearch("nosuchhostokay")
+        }
+
+        assert_equal(dparent, parent, "Default parent node did not match")
+        assert_equal(dclasses, classes, "Default parent class list did not match")
+
+        # Look for a host we know doesn't have a parent
+        npparent, npclasses = ldaphost("noparent")
         assert_nothing_raised {
-            interp.setup_ldap
+            #parent, classes = interp.nodesearch_ldap("noparent")
+            parent, classes = interp.nodesearch("noparent")
         }
 
-        parent = nil
-        classes = nil
+        assert_equal(npparent, parent, "Parent node did not match")
+        assert_equal(npclasses, classes, "Class list did not match")
+
+        # Now look for our normal host
         assert_nothing_raised {
             parent, classes = interp.nodesearch_ldap(hostname)
         }
@@ -164,8 +218,103 @@ class TestInterpreter < Test::Unit::TestCase
             assert(FileTest.exists?(cfile), "Did not make %s" % cfile)
         }
     end
+
+    if Process.uid == 0 and Facter["hostname"].value == "culain"
+    def test_ldapreconnect
+        Puppet[:ldapbase] = "ou=hosts, dc=madstop, dc=com"
+        Puppet[:ldapnodes] = true
+
+        interp = nil
+        assert_nothing_raised {
+            interp = Puppet::Parser::Interpreter.new(
+                :Manifest => mktestmanifest()
+            )
+        }
+        hostname = "culain.madstop.com"
+
+        # look for our host
+        assert_nothing_raised {
+            parent, classes = interp.nodesearch_ldap(hostname)
+        }
+
+        # Now restart ldap
+        system("/etc/init.d/slapd restart 2>/dev/null >/dev/null")
+        sleep(1)
+
+        # and look again
+        assert_nothing_raised {
+            parent, classes = interp.nodesearch_ldap(hostname)
+        }
+
+        # Now stop ldap
+        system("/etc/init.d/slapd stop 2>/dev/null >/dev/null")
+        cleanup do
+            system("/etc/init.d/slapd start 2>/dev/null >/dev/null")
+        end
+
+        # And make sure we actually fail here
+        assert_raise(Puppet::Error) {
+            parent, classes = interp.nodesearch_ldap(hostname)
+        }
+    end
+    else
+        $stderr.puts "Run as root for ldap reconnect tests"
+    end
     end
     else
         $stderr.puts "Not in madstop.com; skipping ldap tests"
     end
+
+    # Make sure searchnode behaves as we expect.
+    def test_nodesearch
+        # First create a fake nodesearch algorithm
+        i = 0
+        bucket = []
+        Puppet::Parser::Interpreter.send(:define_method, "nodesearch_fake") do |node|
+            return nil, nil if node == "default"
+
+            return bucket[0], bucket[1]
+        end
+        text = %{
+node nodeparent {}
+node othernodeparent {}
+class nodeclass {}
+class nothernode {}
+}
+        manifest = tempfile()
+        File.open(manifest, "w") do |f| f.puts text end
+        interp = nil
+        assert_nothing_raised {
+            interp = Puppet::Parser::Interpreter.new(
+                :Manifest => manifest,
+                :NodeSources => [:fake]
+            )
+        }
+        # Make sure it behaves correctly for all forms
+        [[nil, nil],
+        ["nodeparent", nil],
+        [nil, ["nodeclass"]],
+        [nil, ["nodeclass", "nothernode"]],
+        ["othernodeparent", ["nodeclass", "nothernode"]],].each do |ary|
+            # Set the return values
+            bucket = ary
+
+            # Look them back up
+            parent, classes = interp.nodesearch("mynode")
+
+            # Basically, just make sure that if we have either or both,
+            # we get a result back.
+            assert_equal(ary[0], parent,
+                "Parent is not %s" % parent)
+            assert_equal(ary[1], classes,
+                "Parent is not %s" % parent)
+
+            next if ary == [nil, nil]
+            # Now make sure we actually get the configuration.  This will throw
+            # an exception if we don't.
+            assert_nothing_raised do
+                interp.run("mynode", {})
+            end
+        end
+    end
 end

data/test/language/lexer.rb

@@ -69,7 +69,6 @@ class TestLexer < Test::Unit::TestCase
     def test_errors
         strings = %w{
             ^
-            @
         }
         strings.each { |str|
             @lexer.string = str
@@ -122,7 +121,41 @@ class TestLexer < Test::Unit::TestCase
         assert_nothing_raised {
             @lexer.string = bit
         }
+
+        assert_nothing_raised {
+            @lexer.fullscan
+        }
+    end
+
+    def test_collectlexing
+        {"@" => :AT, "<|" => :LCOLLECT, "|>" => :RCOLLECT}.each do |string, token|
+            assert_nothing_raised {
+                @lexer.string = string
+            }
+
+            ret = nil
+            assert_nothing_raised {
+                ret = @lexer.fullscan
+            }
+
+            assert_equal([[token, string],[false, false]], ret)
+        end
+    end
+
+    def test_collectabletype
+        string = "@type {"
+
+        assert_nothing_raised {
+            @lexer.string = string
+        }
+
+        ret = nil
+        assert_nothing_raised {
+            ret = @lexer.fullscan
+        }
+
+        assert_equal([[:AT, "@"], [:NAME, "type"], [:LBRACE, "{"], [false,false]],ret)
     end
 end
 
-# $Id: lexer.rb 1070 2006-04-04 23:30:56Z luke $
+# $Id: lexer.rb 1189 2006-05-13 18:27:22Z luke $

data/test/language/node.rb

@@ -49,7 +49,7 @@ class TestParser < Test::Unit::TestCase
             hostnames = [ hostnames ]
         end
         assert_nothing_raised {
-            @parser.string = "node #{hostnames.join(" ")} { }"
+            @parser.string = "node #{hostnames.join(", ")} { }"
         }
         # Strip quotes
         hostnames.map! { |s| s.sub(/^'(.*)'$/, "\\1") }
@@ -81,4 +81,51 @@ class TestParser < Test::Unit::TestCase
             @parser.parse
         }
     end
+
+    # Make sure we can find default nodes if there's no other entry
+    def test_default_node
+        Puppet[:parseonly] = false
+        @parser = Puppet::Parser::Parser.new()
+
+        fileA = tempfile()
+        fileB = tempfile()
+        @parser.string = %{
+node mynode {
+    file { "#{fileA}": ensure => file }
+}
+
+node default {
+    file { "#{fileB}": ensure => file }
+}
+}
+
+        # First make sure it parses
+        ast = nil
+        assert_nothing_raised {
+            ast = @parser.parse
+        }
+
+        args = {
+            :ast => ast,
+            :facts => {},
+            :names => ["mynode"]
+        }
+        # Make sure we get a config for "mynode"
+
+        trans = nil
+        assert_nothing_raised {
+            trans = Puppet::Parser::Scope.new.evaluate(args)
+        }
+
+        assert(trans, "Did not get config for mynode")
+
+        args[:names] = ["othernode"]
+        # Now make sure the default node is used
+        trans = nil
+        assert_nothing_raised {
+            trans = Puppet::Parser::Scope.new.evaluate(args)
+        }
+
+        assert(trans, "Did not get config for default node")
+    end
 end

data/test/language/parser.rb

@@ -207,6 +207,255 @@ class TestParser < Test::Unit::TestCase
             parser.parse
         }
     end
+
+    def test_importedclasses
+        imported = tempfile()
+        importer = tempfile()
+
+        made = tempfile()
+
+        File.open(imported, "w") do |f|
+            f.puts %{class foo { file { "#{made}": ensure => file }}}
+        end
+
+        File.open(importer, "w") do |f|
+            f.puts %{import "#{imported}"\ninclude foo}
+        end
+
+        parser = Puppet::Parser::Parser.new
+        parser.file = importer
+
+        # Make sure it parses fine
+        assert_nothing_raised {
+            parser.parse
+        }
+
+        # Now make sure it actually does the work
+        assert_creates(importer, made)
+    end
+
+    # Make sure fully qualified and unqualified files can be imported
+    def test_fqfilesandlocalfiles
+        dir = tempfile()
+        Dir.mkdir(dir)
+        importer = File.join(dir, "site.pp")
+        fullfile = File.join(dir, "full.pp")
+        localfile = File.join(dir, "local.pp")
+
+        files = []
+
+        File.open(importer, "w") do |f|
+            f.puts %{import "#{fullfile}"\ninclude full\nimport "local.pp"\ninclude local}
+        end
+
+        file = tempfile()
+        files << file
+
+        File.open(fullfile, "w") do |f|
+            f.puts %{class full { file { "#{file}": ensure => file }}}
+        end
+
+        file = tempfile()
+        files << file
+
+        File.open(localfile, "w") do |f|
+            f.puts %{class local { file { "#{file}": ensure => file }}}
+        end
+
+        parser = Puppet::Parser::Parser.new
+        parser.file = importer
+
+        # Make sure it parses
+        assert_nothing_raised {
+            parser.parse
+        }
+
+        # Now make sure it actually does the work
+        assert_creates(importer, *files)
+    end
+
+    # Make sure the parser adds '.pp' when necessary
+    def test_addingpp
+        dir = tempfile()
+        Dir.mkdir(dir)
+        importer = File.join(dir, "site.pp")
+        localfile = File.join(dir, "local.pp")
+
+        files = []
+
+        File.open(importer, "w") do |f|
+            f.puts %{import "local"\ninclude local}
+        end
+
+        file = tempfile()
+        files << file
+
+        File.open(localfile, "w") do |f|
+            f.puts %{class local { file { "#{file}": ensure => file }}}
+        end
+
+        parser = Puppet::Parser::Parser.new
+        parser.file = importer
+
+        assert_nothing_raised {
+            parser.parse
+        }
+    end
+
+    # Make sure that file importing changes file relative names.
+    def test_changingrelativenames
+        dir = tempfile()
+        Dir.mkdir(dir)
+        Dir.mkdir(File.join(dir, "subdir"))
+        top = File.join(dir, "site.pp")
+        subone = File.join(dir, "subdir/subone")
+        subtwo = File.join(dir, "subdir/subtwo")
+
+        files = []
+        file = tempfile()
+        files << file
+
+        File.open(subone + ".pp", "w") do |f|
+            f.puts %{class one { file { "#{file}": ensure => file }}}
+        end
+
+        otherfile = tempfile()
+        files << otherfile
+        File.open(subtwo + ".pp", "w") do |f|
+            f.puts %{import "subone"\n class two inherits one {
+                file { "#{otherfile}": ensure => file }
+            }}
+        end
+
+        File.open(top, "w") do |f|
+            f.puts %{import "subdir/subtwo"}
+        end
+
+        parser = Puppet::Parser::Parser.new
+        parser.file = top
+
+        assert_nothing_raised {
+            parser.parse
+        }
+    end
+
+    # Verify that collectable objects are marked that way.
+    def test_collectable
+        Puppet[:storeconfigs] = true
+        ["@port { ssh: protocols => tcp, number => 22 }",
+         "@port { ssh: protocols => tcp, number => 22;
+            smtp: protocols => tcp, number => 25 }"].each do |text|
+            parser = Puppet::Parser::Parser.new
+            parser.string = text
+
+            ret = nil
+            assert_nothing_raised {
+                ret = parser.parse
+            }
+
+            assert_instance_of(AST::ASTArray, ret)
+
+            ret.each do |obj|
+                assert_instance_of(AST::ObjectDef, obj)
+                assert(obj.collectable, "Object was not marked collectable")
+            end
+        end
+    end
+
+    # Defaults are purely syntactical, so it doesn't make sense to be able to
+    # collect them.
+    def test_uncollectabledefaults
+        string = "@Port { protocols => tcp }"
+        parser = Puppet::Parser::Parser.new
+        parser.string = string
+
+        assert_raise(Puppet::ParseError) {
+            parser.parse
+        }
+    end
+
+    # Verify that we can parse collections
+    def test_collecting
+        Puppet[:storeconfigs] = true
+        text = "port <| |>"
+        parser = Puppet::Parser::Parser.new
+        parser.string = text
+
+        ret = nil
+        assert_nothing_raised {
+            ret = parser.parse
+        }
+
+        assert_instance_of(AST::ASTArray, ret)
+
+        ret.each do |obj|
+            assert_instance_of(AST::Collection, obj)
+        end
+    end
+
+    def test_emptyfile
+        file = tempfile()
+        File.open(file, "w") do |f|
+            f.puts %{}
+        end
+        parser = Puppet::Parser::Parser.new
+        parser.file = file
+        assert_nothing_raised {
+            parser.parse
+        }
+    end
+
+    def test_multiple_nodes_named
+        file = tempfile()
+        other = tempfile()
+
+        File.open(file, "w") do |f|
+            f.puts %{
+node nodeA, nodeB {
+    file { "#{other}": ensure => file }
+    
+}
+}
+        end
+
+        parser = Puppet::Parser::Parser.new
+        parser.file = file
+        ast = nil
+        assert_nothing_raised {
+            ast = parser.parse
+        }
+    end
+
+    def test_emptyarrays
+        str = %{$var = []\n}
+
+        parser = Puppet::Parser::Parser.new
+        parser.string = str
+
+        # Make sure it parses fine
+        assert_nothing_raised {
+            parser.parse
+        }
+    end
+
+    # Make sure function names aren't reserved words.
+    def test_functionnamecollision
+        str = %{tag yayness
+tag(rahness)
+
+file { "/tmp/yayness":
+    tag => "rahness",
+    ensure => exists
+}
+}
+        parser = Puppet::Parser::Parser.new
+        parser.string = str
+
+        # Make sure it parses fine
+        assert_nothing_raised {
+            parser.parse
+        }
+    end
 end
 
-# $Id: parser.rb 1070 2006-04-04 23:30:56Z luke $
+# $Id: parser.rb 1245 2006-06-08 20:06:41Z luke $