puppet 0.13.6 → 0.16.0

data/test/client/master.rb

@@ -10,18 +10,20 @@ require 'puppet/server'
 require 'test/unit'
 require 'puppettest.rb'
 
-# $Id: master.rb 908 2006-02-14 00:14:56Z luke $
+# $Id: master.rb 1107 2006-04-11 23:00:29Z luke $
 
 class TestMasterClient < Test::Unit::TestCase
 	include ServerTest
 
-    def mkmaster(file)
+    def mkmaster(file = nil)
         master = nil
+
+        file ||= mktestmanifest()
         # create our master
         assert_nothing_raised() {
             # this is the default server setup
             master = Puppet::Server::Master.new(
-                :File => file,
+                :Manifest => file,
                 :UseNodes => false,
                 :Local => true
             )
@@ -29,7 +31,8 @@ class TestMasterClient < Test::Unit::TestCase
         return master
     end
 
-    def mkclient(master)
+    def mkclient(master = nil)
+        master ||= mkmaster()
         client = nil
         assert_nothing_raised() {
             client = Puppet::Client::MasterClient.new(
@@ -69,4 +72,47 @@ class TestMasterClient < Test::Unit::TestCase
 
         assert(FileTest.exists?(@createdfile), "Enabled client did not run")
     end
+
+    # Make sure we're getting the client version in our list of facts
+    def test_clientversionfact
+        facts = nil
+        assert_nothing_raised {
+            facts = Puppet::Client::MasterClient.facts
+        }
+
+        assert_equal(Puppet.version.to_s, facts["clientversion"])
+        
+    end
+
+    # Make sure the client correctly locks itself
+    def test_locking
+        manifest = mktestmanifest
+
+        master = nil
+
+        # First test with a networked master
+        client = Puppet::Client::MasterClient.new(
+            :Server => "localhost"
+        )
+
+        assert_nothing_raised do
+            client.lock do
+                pid = nil
+                assert(pid = client.locked?, "Client is not locked")
+                assert(pid =~ /^\d+$/, "PID is, um, not a pid")
+            end
+        end
+        assert(! client.locked?)
+
+        # Now test with a local client
+        client = mkclient
+
+        assert_nothing_raised do
+            client.lock do
+                pid = nil
+                assert(! client.locked?, "Local client is locked")
+            end
+        end
+        assert(! client.locked?)
+    end
 end

data/test/executables/puppetbin.rb

@@ -17,12 +17,11 @@ class TestPuppetBin < Test::Unit::TestCase
         assert_nothing_raised {
           output = %x{puppet --version}.chomp
         }
-        assert(output == Puppet.version)
+        assert_equal(Puppet.version, output)
     end
 
     def test_execution
         file = mktestmanifest()
-        @@tmpfiles << tempfile()
 
         output = nil
         cmd = "puppet"
@@ -32,7 +31,9 @@ class TestPuppetBin < Test::Unit::TestCase
         #cmd += " --fqdn %s" % fqdn
         cmd += " --confdir %s" % Puppet[:confdir]
         cmd += " --vardir %s" % Puppet[:vardir]
-        cmd += " --logdest %s" % "/dev/null"
+        unless Puppet[:debug]
+            cmd += " --logdest %s" % "/dev/null"
+        end
 
         assert_nothing_raised {
             system(cmd + " " + file)
@@ -41,6 +42,32 @@ class TestPuppetBin < Test::Unit::TestCase
 
         assert(FileTest.exists?(@createdfile), "Failed to create config'ed file")
     end
+
+    def test_inlineexecution
+        path = tempfile()
+        code = "file { '#{path}': ensure => file }"
+
+        output = nil
+        cmd = "puppet"
+        if Puppet[:debug]
+            cmd += " --debug"
+        end
+        #cmd += " --fqdn %s" % fqdn
+        cmd += " --confdir %s" % Puppet[:confdir]
+        cmd += " --vardir %s" % Puppet[:vardir]
+        unless Puppet[:debug]
+            cmd += " --logdest %s" % "/dev/null"
+        end
+
+        cmd += " -e \"#{code}\""
+
+        assert_nothing_raised {
+            system(cmd)
+        }
+        assert($? == 0, "Puppet exited with code %s" % $?.to_i)
+
+        assert(FileTest.exists?(path), "Failed to create config'ed file")
+    end
 end
 
-# $Id: $
+# $Id: puppetbin.rb 1065 2006-04-04 22:23:08Z luke $

data/test/executables/puppetca.rb

@@ -25,7 +25,11 @@ class TestPuppetCA < Test::Unit::TestCase
     end
     
     def runca(args)
-        return %x{puppetca --confdir=#{Puppet[:confdir]} --user #{Process.uid} --group #{Process.gid} #{args} 2>&1}
+        debug = ""
+        if Puppet[:debug]
+            debug = "-d "
+        end
+        return %x{puppetca --user=#{Puppet[:user]} #{debug} --group=#{Puppet[:group]} --confdir=#{Puppet[:confdir]} #{args} 2>&1}
 
     end
 
@@ -60,8 +64,20 @@ class TestPuppetCA < Test::Unit::TestCase
         assert_nothing_raised {
             output = runca("--sign -a").chomp.split("\n")
         }
+
+
         assert_equal($?,0)
         assert_equal(["Signed host.test.com"], output)
+
+        signedfile = File.join(Puppet[:signeddir], "host.test.com.pem")
+        assert(FileTest.exists?(signedfile), "cert does not exist")
+        assert(! FileTest.executable?(signedfile), "cert is executable")
+
+        uid = Puppet::Util.uid(Puppet[:user])
+
+        if Process.uid == 0
+            assert(! FileTest.owned?(signedfile), "cert is owned by root")
+        end
         assert_nothing_raised {
             output = runca("--list").chomp.split("\n")
         }
@@ -70,4 +86,4 @@ class TestPuppetCA < Test::Unit::TestCase
     end
 end
 
-# $Id: puppetca.rb 873 2006-02-07 23:12:33Z luke $
+# $Id: puppetca.rb 1113 2006-04-17 16:15:33Z luke $

data/test/language/ast.rb

@@ -29,6 +29,7 @@ class TestAST < Test::Unit::TestCase
 
         # Create child class two
         children << classobj("child2", :parentclass => nameobj("parent"))
+        classes = %w{parent child1 child2}
 
         # Now call the two classes
         assert_nothing_raised("Could not add AST nodes for calling") {
@@ -60,11 +61,13 @@ class TestAST < Test::Unit::TestCase
         assert_equal(1, scope.find_all { |child|
             child.lookupobject(:name => "/parent", :type => "file")
         }.length, "Found incorrect number of '/parent' objects")
+
+        assert_equal(classes.sort, scope.classlist.sort)
     end
 
-    # Test that 'setobject' collects all of an object's parameters and stores
+    # Test that 'tagobject' collects all of an object's parameters and stores
     # them in one TransObject, rather than many.  This is probably a bad idea.
-    def test_setobject
+    def test_tagobject
         top = nil
         children = [
             fileobj("/etc", "owner" => "root"),
@@ -128,8 +131,122 @@ class TestAST < Test::Unit::TestCase
         }
     end
 
+    # Verify that nodes don't evaluate code in other node scopes but that their
+    # facts work outside their scopes.
+    def test_nodescopes
+        parent = child1 = nil
+        topchildren = []
+
+        # create the parent class
+        topchildren << classobj("everyone")
+
+        topchildren << classobj("parent")
+
+
+        classes = %w{everyone parent}
+
+        # And a variable, so we verify the facts get set at the top
+        assert_nothing_raised {
+            children = []
+            children << varobj("yaytest", "$hostname")
+        }
+
+        nodes = []
+
+        3.times do |i|
+            children = []
+
+            # Create a child class
+            topchildren << classobj("perchild#{i}", :parentclass => nameobj("parent"))
+            classes << "perchild%s"
+
+            # Create a child class
+            children << classobj("child", :parentclass => nameobj("parent"))
+
+            classes << "child"
+
+            ["child", "everyone", "perchild#{i}"].each do |name|
+                # Now call our child class
+                assert_nothing_raised {
+                    children << AST::ObjectDef.new(
+                        :type => nameobj(name),
+                        :params => astarray()
+                    )
+                }
+            end
+
+            # and another variable
+            assert_nothing_raised {
+                children << varobj("rahtest", "$hostname")
+            }
+
+            # create the node
+            nodename = "node#{i}"
+            nodes << nodename
+            assert_nothing_raised("Could not create parent object") {
+                topchildren << AST::NodeDef.new(
+                    :names => nameobj(nodename),
+                    :code => AST::ASTArray.new(
+                        :children => children
+                    )
+                )
+            }
+        end
+
+        # Create the wrapper object
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => topchildren
+            )
+        }
+
+        nodes.each_with_index do |node, i|
+            # Evaluate the parse tree
+            scope = Puppet::Parser::Scope.new()
+            args = {:names => [node], :facts => {"hostname" => node}, :ast => top}
+
+            # verify that we can evaluate it okay
+            trans = nil
+            assert_nothing_raised("Could not retrieve node definition") {
+                trans = scope.evaluate(args)
+            }
+
+            assert_equal(node, scope.lookupvar("hostname"))
+
+            assert(trans, "Could not retrieve trans objects")
+
+            # and that we can convert them to type objects
+            objects = nil
+            assert_nothing_raised("Could not retrieve node definition") {
+                objects = trans.to_type
+            }
+
+            assert(objects, "Could not retrieve trans objects")
+
+            count = 0
+            # Make sure the node name gets into the path correctly.
+            Puppet.type(:file).each { |obj|
+                count += 1
+                assert(obj.path !~ /#{node}\[#{node}\]/,
+                    "Node name appears twice")
+            }
+
+            assert(count > 0, "Did not create any files")
+
+            classes.each do |name|
+                if name =~ /%s/
+                    name = name % i
+                end
+                assert(Puppet::Type.type(:file)["/#{name}"], "Could not find '#{name}'")
+            end
+
+            Puppet::Type.type(:file).clear
+        end
+    end
+
     # Verify that classes are correctly defined in node scopes.
-    def test_nodeclasslookup
+    def disabled_test_nodeclasslookup
         parent = child1 = nil
         children = []
 
@@ -234,11 +351,11 @@ class TestAST < Test::Unit::TestCase
 
         # create a short-name node
         shortname = "mynodename"
-        children << nodeobj(shortname)
+        children << nodedef(shortname)
 
         # And a long-name node
         longname = "node.domain.com"
-        children << nodeobj(longname)
+        children << nodedef(longname)
 
         # Create the wrapper object
         top = nil
@@ -249,25 +366,25 @@ class TestAST < Test::Unit::TestCase
         }
 
         # Evaluate the parse tree
-        scope = nil
-        assert_nothing_raised("Could not evaluate node") {
-            scope = Puppet::Parser::Scope.new()
-            top.evaluate(:scope => scope)
-        }
+        scope = Puppet::Parser::Scope.new()
 
         # Verify we can find the node via a search list
         objects = nil
         assert_nothing_raised("Could not retrieve short node definition") {
-            objects = scope.evalnode(
-                :name => ["%s.domain.com" % shortname, shortname], :facts => {}
+            objects = scope.evaluate(
+                :names => ["%s.domain.com" % shortname, shortname], :facts => {},
+                :ast => top
             )
         }
         assert(objects, "Could not retrieve short node definition")
 
+        scope = Puppet::Parser::Scope.new()
+
         # and then look for the long name
         assert_nothing_raised("Could not retrieve long node definition") {
-            objects = scope.evalnode(
-                :name => [longname.sub(/\..+/, ''), longname], :facts => {}
+            objects = scope.evaluate(
+                :names => [longname.sub(/\..+/, ''), longname], :facts => {},
+                :ast => top
             )
         }
         assert(objects, "Could not retrieve long node definition")
@@ -282,7 +399,7 @@ class TestAST < Test::Unit::TestCase
 
         # create a short-name node
         name = "mynodename"
-        children << nodeobj(name)
+        children << nodedef(name)
 
         # Create the wrapper object
         top = nil
@@ -292,17 +409,12 @@ class TestAST < Test::Unit::TestCase
             )
         }
 
-        # Evaluate the parse tree
-        scope = nil
-        assert_nothing_raised("Could not evaluate node") {
-            scope = Puppet::Parser::Scope.new()
-            top.evaluate(:scope => scope)
-        }
+        scope = Puppet::Parser::Scope.new()
 
         # Verify we can find the node via a search list
         objects = nil
         assert_nothing_raised("Could not retrieve short node definition") {
-            objects = scope.evalnode(:name => [name], :facts => {})
+            objects = scope.evaluate(:names => [name], :facts => {}, :ast => top)
         }
         assert(objects, "Could not retrieve short node definition")
 
@@ -319,10 +431,12 @@ class TestAST < Test::Unit::TestCase
     # Test that we can 'include' variables, not just normal strings.
     def test_includevars
         children = []
+        classes = []
 
         # Create our class for testin
         klassname = "include"
         children << classobj(klassname)
+        classes << klassname
 
         # Then add our variable assignment
         children << varobj("klassvar", klassname)
@@ -345,6 +459,9 @@ class TestAST < Test::Unit::TestCase
             top.evaluate(:scope => scope)
         }
 
+        # Verify we get the right classlist back
+        assert_equal(classes.sort, scope.classlist.sort)
+
         # Verify we can find the node via a search list
         objects = nil
         assert_nothing_raised("Could not retrieve objects") {
@@ -363,7 +480,7 @@ class TestAST < Test::Unit::TestCase
 
         # create the base node
         name = "basenode"
-        children << nodeobj(name)
+        children << nodedef(name)
 
         # and the sub node
         name = "subnode"
@@ -377,7 +494,7 @@ class TestAST < Test::Unit::TestCase
                 ]
             )
         )
-        #subnode = nodeobj(name)
+        #subnode = nodedef(name)
         #subnode.parentclass = "basenode"
 
         #children << subnode
@@ -391,16 +508,12 @@ class TestAST < Test::Unit::TestCase
         }
 
         # Evaluate the parse tree
-        scope = nil
-        assert_nothing_raised("Could not evaluate node") {
-            scope = Puppet::Parser::Scope.new()
-            top.evaluate(:scope => scope)
-        }
+        scope = Puppet::Parser::Scope.new()
 
         # Verify we can find the node via a search list
         objects = nil
-        assert_nothing_raised("Could not retrieve node definition") {
-            objects = scope.evalnode(:name => [name], :facts => {})
+        assert_nothing_raised("Could not evaluate node") {
+            objects = scope.evaluate(:names => [name], :facts => {}, :ast => top)
         }
         assert(objects, "Could not retrieve node definition")
 
@@ -531,4 +644,61 @@ class TestAST < Test::Unit::TestCase
             objects = top.evaluate(:scope => scope)
         }
     end
+
+    def test_setclass
+        type = "yay"
+        classes = [type]
+        children = []
+        # Create child class one
+        children << varobj("variable", "aclass")
+        children << tagobj(type, varref("variable"))
+        children << tagobj(type)
+
+        classes << "aclass"
+
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        scope = nil
+        assert_nothing_raised("Could not evaluate") {
+            scope = Puppet::Parser::Scope.new()
+            objects = top.evaluate(:scope => scope)
+        }
+
+
+        classes.each do |tag|
+            assert(scope.classlist.include?(tag), "Did not set class %s" % tag)
+        end
+
+    end
+
+    # Test that we strip the domain off of host names before they are set as classes
+    def test_nodenamestrip
+        children = []
+
+        longname = "node.domain.com"
+        children << nodedef(longname)
+
+        # Create the wrapper object
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        scope = Puppet::Parser::Scope.new()
+
+        assert_nothing_raised("Could not evaluate node") {
+            objects = scope.evaluate(:names => [longname], :facts => {}, :ast => top)
+        }
+
+        assert(!scope.classlist.include?("node.domain.com"),
+            "Node's long name got set")
+        assert(scope.classlist.include?("node"), "Node's name did not get set")
+    end
 end