puppet 0.9.2

data/test/executables/puppetbin.rb

@@ -0,0 +1,53 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/server'
+require 'puppet/sslcertificates'
+require 'test/unit'
+require 'puppettest.rb'
+
+# add the bin directory to our search path
+ENV["PATH"] += ":" + File.join($puppetbase, "bin")
+
+# and then the library directories
+libdirs = $:.find_all { |dir|
+    dir =~ /puppet/ or dir =~ /\.\./
+}
+ENV["RUBYLIB"] = libdirs.join(":")
+
+class TestPuppetBin < Test::Unit::TestCase
+	include ServerTest
+    def test_version
+        output = nil
+        assert_nothing_raised {
+          output = %x{puppet --version}.chomp
+        }
+        assert(output == Puppet.version)
+    end
+
+    def test_execution
+        file = mktestmanifest()
+        @@tmpfiles << "/tmp/puppetbintesting"
+
+        output = nil
+        cmd = "puppet"
+        cmd += " --verbose"
+        #cmd += " --fqdn %s" % fqdn
+        cmd += " --confdir %s" % Puppet[:puppetconf]
+        cmd += " --vardir %s" % Puppet[:puppetvar]
+        cmd += " --logdest %s" % "/dev/null"
+
+        assert_nothing_raised {
+            system(cmd + " " + file)
+        }
+        assert($? == 0, "Puppet exited with code %s" % $?.to_i)
+
+        assert(FileTest.exists?(@createdfile), "Failed to create config'ed file")
+    end
+end
+
+# $Id: $

data/test/executables/puppetca.rb

@@ -0,0 +1,79 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/server'
+require 'puppet/sslcertificates'
+require 'test/unit'
+require 'puppettest.rb'
+
+# $Id: puppetca.rb 724 2005-10-22 22:27:20Z luke $
+
+# ok, we have to add the bin directory to our search path
+ENV["PATH"] += ":" + File.join($puppetbase, "bin")
+
+# and then the library directories
+libdirs = $:.find_all { |dir|
+    dir =~ /puppet/ or dir =~ /\.\./
+}
+ENV["RUBYLIB"] = libdirs.join(":")
+
+class TestPuppetCA < Test::Unit::TestCase
+	include ServerTest
+    def mkcert(hostname)
+        cert = nil
+        assert_nothing_raised {
+            cert = Puppet::SSLCertificates::Certificate.new(
+                :name => hostname
+            )
+            cert.mkcsr
+        }
+
+        return cert
+    end
+
+    def test_signing
+        ca = nil
+        Puppet[:ssldir] = "/tmp/puppetcatest"
+        @@tmpfiles << Puppet[:ssldir]
+        Puppet[:autosign] = false
+        assert_nothing_raised {
+            ca = Puppet::Server::CA.new()
+        }
+        #Puppet.warning "SSLDir is %s" % Puppet[:ssldir]
+        #system("find %s" % Puppet[:ssldir])
+
+        cert = mkcert("host.test.com")
+        resp = nil
+        assert_nothing_raised {
+            # We need to use a fake name so it doesn't think the cert is from
+            # itself.
+            resp = ca.getcert(cert.csr.to_pem, "fakename", "127.0.0.1")
+        }
+        assert_equal(["",""], resp)
+        #Puppet.warning "SSLDir is %s" % Puppet[:ssldir]
+        #system("find %s" % Puppet[:ssldir])
+
+        output = nil
+        assert_nothing_raised {
+            output = %x{puppetca --list --ssldir=#{Puppet[:ssldir]} 2>&1}.chomp.split("\n").reject { |line| line =~ /warning:/ } # stupid ssl.rb
+        }
+        #Puppet.warning "SSLDir is %s" % Puppet[:ssldir]
+        #system("find %s" % Puppet[:ssldir])
+        assert_equal($?,0)
+        assert_equal(%w{host.test.com}, output)
+        assert_nothing_raised {
+            output = %x{puppetca --sign -a --ssldir=#{Puppet[:ssldir]}}.chomp.split("\n")
+        }
+        assert_equal($?,0)
+        assert_equal([], output)
+        assert_nothing_raised {
+            output = %x{puppetca --list --ssldir=#{Puppet[:ssldir]}}.chomp.split("\n")
+        }
+        assert_equal($?,0)
+        assert_equal([], output)
+    end
+end

data/test/executables/puppetd.rb

@@ -0,0 +1,71 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/server'
+require 'test/unit'
+require 'puppettest.rb'
+require 'socket'
+require 'facter'
+
+# $Id: puppetd.rb 731 2005-10-26 04:44:25Z luke $
+
+# ok, we have to add the bin directory to our search path
+ENV["PATH"] += ":" + File.join($puppetbase, "bin")
+
+# and then the library directories
+libdirs = $:.find_all { |dir|
+    dir =~ /puppet/ or dir =~ /\.\./
+}
+ENV["RUBYLIB"] = libdirs.join(":")
+
+class TestPuppetDExe < Test::Unit::TestCase
+	include ExeTest
+    def test_normalstart
+        # start the master
+        file = startmasterd
+
+        # create the client
+        client = Puppet::Client.new(:Server => "localhost", :Port => @@port)
+
+        # make a new fqdn
+        fqdn = client.fqdn.sub(/^\w+\./, "testing.")
+
+        cmd = "puppetd"
+        cmd += " --verbose"
+        #cmd += " --fqdn %s" % fqdn
+        cmd += " --port %s" % @@port
+        cmd += " --confdir %s" % Puppet[:puppetconf]
+        cmd += " --vardir %s" % Puppet[:puppetvar]
+        cmd += " --server localhost"
+
+        # and verify our daemon runs
+        assert_nothing_raised {
+            output = %x{#{cmd}}.chomp
+            puts output
+        }
+        sleep 1
+        assert($? == 0, "Puppetd exited with code %s" % $?)
+
+        assert(FileTest.exists?(@createdfile),
+            "Failed to create config'ed file")
+
+        # now verify that --noop works
+        File.unlink(@createdfile)
+
+        cmd += " --noop"
+        assert_nothing_raised {
+            output = %x{#{cmd}}.chomp
+        }
+        sleep 1
+        assert($? == 0, "Puppetd exited with code %s" % $?)
+
+        assert(! FileTest.exists?(@createdfile),
+            "Noop created config'ed file")
+
+        stopmasterd
+    end
+end

data/test/executables/puppetmasterd.rb

@@ -0,0 +1,153 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/server'
+require 'puppet/daemon'
+require 'test/unit'
+require 'puppettest.rb'
+require 'socket'
+require 'facter'
+
+# $Id: puppetmasterd.rb 732 2005-10-28 05:39:59Z luke $
+
+class TestPuppetMasterD < Test::Unit::TestCase
+	include ExeTest
+    def getcerts
+        include Puppet::Daemon
+        if self.readcerts
+            return [@cert, @key, @cacert, @cacertfile]
+        else
+            raise "Couldn't read certs"
+        end
+    end
+
+    # start the daemon and verify it responds and such
+    def test_normalstart
+        startmasterd
+
+        pidfile = File.join(Puppet[:puppetvar], "puppetmasterd.pid")
+        assert(FileTest.exists?(pidfile), "PID file does not exist")
+
+        sleep(1)
+        assert_nothing_raised {
+            socket = TCPSocket.new("127.0.0.1", @@port)
+            socket.close
+        }
+
+        client = nil
+        assert_nothing_raised() {
+            client = Puppet::Client::StatusClient.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+        }
+
+        # set our client up to auto-sign
+        assert(Puppet[:autosign] =~ /^#{File::SEPARATOR}/,
+            "Autosign is set to %s, not a file" % Puppet[:autosign])
+
+        FileUtils.mkdir_p(File.dirname(Puppet[:autosign]))
+        File.open(Puppet[:autosign], "w") { |f|
+            f.puts client.fqdn
+        }
+
+        retval = nil
+
+        # init the client certs
+        assert_nothing_raised() {
+            client.initcerts
+        }
+
+        # call status
+        assert_nothing_raised() {
+            retval = client.status
+        }
+        assert_equal(1, retval, "Status.status return value was %s" % retval)
+
+        # this client shoulduse the same certs
+        assert_nothing_raised() {
+            client = Puppet::Client::MasterClient.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+        }
+        assert_nothing_raised() {
+            #Puppet.notice "calling status"
+            #retval = client.call("status.status", "")
+            retval = client.getconfig
+        }
+
+        objects = nil
+        assert_instance_of(Puppet::TransBucket, retval,
+            "Retrieved non-transportable object")
+        stopmasterd
+        sleep(1)
+    end
+
+    # verify that we can run puppetmasterd in parse-only mode
+    def test_parseonly
+        startmasterd("--parseonly > /dev/null")
+        sleep(1)
+
+        pid = nil
+        ps = Facter["ps"].value || "ps -ef"
+        %x{#{ps}}.chomp.split(/\n/).each { |line|
+            if line =~ /puppetmasterd --manifest/
+                ary = line.split(" ")
+                pid = ary[1].to_i
+            end
+        }
+
+        assert($? == 0, "Puppetmasterd ended with non-zero exit status")
+
+        assert_nil(pid, "Puppetmasterd is still running after parseonly")
+    end
+
+    def disabled_test_sslconnection
+        #file = File.join($puppetbase, "examples", "code", "head")
+        #startmasterd("--manifest #{file}")
+
+        #assert_nothing_raised {
+        #    socket = TCPSocket.new("127.0.0.1", Puppet[:masterport])
+        #    socket.close
+        #}
+
+        client = nil
+        cert, key, cacert, cacertfile = getcerts()
+
+        assert_nothing_raised() {
+            client = Net::HTTP.new("localhost", Puppet[:masterport])
+            client.cert = cert
+            client.key = key
+            client.ca_file = cacertfile
+            client.use_ssl = true
+            client.start_immediately = true
+        }
+        retval = nil
+
+        assert_nothing_raised() {
+            retval = client.nothing
+        }
+        assert_equal(1, retval, "return value was %s" % retval)
+        facts = {}
+        Facter.each { |p,v|
+            facts[p] = v
+        }
+        textfacts = CGI.escape(Marshal::dump(facts))
+        assert_nothing_raised() {
+            #Puppet.notice "calling status"
+            #retval = client.call("status.status", "")
+            retval = client.call("puppetmaster.getconfig", textfacts)
+        }
+
+        objects = nil
+        assert_nothing_raised {
+            Marshal::load(CGI.unescape(retval))
+        }
+        #stopmasterd
+    end
+end

data/test/executables/puppetmodule.rb

@@ -0,0 +1,60 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/server'
+require 'puppet/sslcertificates'
+require 'test/unit'
+require 'puppettest.rb'
+
+# add the bin directory to our search path
+ENV["PATH"] += ":" + File.join($puppetbase, "bin")
+
+# and then the library directories
+libdirs = $:.find_all { |dir|
+    dir =~ /puppet/ or dir =~ /\.\./
+}
+ENV["RUBYLIB"] = libdirs.join(":")
+
+$module = File.join($puppetbase, "ext", "module:puppet")
+
+class TestPuppetModule < Test::Unit::TestCase
+	include ServerTest
+
+    def test_execution
+        file = tempfile()
+
+        createdfile = tempfile()
+
+        File.open(file, "w") { |f|
+            f.puts "class yaytest { file { \"#{createdfile}\": create => true } }"
+        }
+
+        output = nil
+        cmd = $module
+        cmd += " --verbose"
+        #cmd += " --fqdn %s" % fqdn
+        cmd += " --confdir %s" % Puppet[:puppetconf]
+        cmd += " --vardir %s" % Puppet[:puppetvar]
+        if Puppet[:debug]
+            cmd += " --logdest %s" % "console"
+        else
+            cmd += " --logdest %s" % "/dev/null"
+        end
+
+        ENV["CFALLCLASSES"] = "yaytest:all"
+
+        Puppet.err :mark
+        assert_nothing_raised {
+            system(cmd + " " + file)
+        }
+        assert($? == 0, "Puppet module exited with code %s" % $?.to_i)
+
+        assert(FileTest.exists?(createdfile), "Failed to create config'ed file")
+    end
+end
+
+# $Id: puppetmodule.rb 746 2005-11-17 21:03:19Z luke $

data/test/language/ast.rb

@@ -0,0 +1,412 @@
+#!/usr/bin/ruby
+
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/parser/interpreter'
+require 'puppet/parser/parser'
+require 'puppet/client'
+require 'test/unit'
+require 'puppettest'
+
+class TestAST < Test::Unit::TestCase
+	include ParserTesting
+
+    # Test that classes behave like singletons
+    def test_classsingleton
+        parent = child1 = child2 = nil
+        children = []
+
+        # create the parent class
+        children << classobj("parent")
+
+        # Create child class one
+        children << classobj("child1", :parentclass => nameobj("parent"))
+
+        # Create child class two
+        children << classobj("child2", :parentclass => nameobj("parent"))
+
+        # Now call the two classes
+        assert_nothing_raised("Could not add AST nodes for calling") {
+            children << AST::ObjectDef.new(
+                :type => nameobj("child1"),
+                :name => nameobj("yayness"),
+                :params => astarray()
+            )
+            children << AST::ObjectDef.new(
+                :type => nameobj("child2"),
+                :name => nameobj("booness"),
+                :params => astarray()
+            )
+        }
+
+        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)
+        }
+
+        assert_equal(1, scope.find_all { |child|
+            child.lookupobject("/parent", "file")
+        }.length, "Found incorrect number of '/parent' objects")
+    end
+
+    # Test that 'setobject' 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
+        top = nil
+        children = [
+            fileobj("/etc", "owner" => "root"),
+            fileobj("/etc", "group" => "root")
+        ]
+        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") {
+            top.evaluate(scope)
+        }
+
+        obj = nil
+        assert_nothing_raised("Could not retrieve file object") {
+            obj = scope.lookupobject("/etc", "file")
+        }
+
+        assert(obj, "could not retrieve file object")
+
+        %w{owner group}.each { |param|
+            assert(obj.include?(param), "Object did not include %s" % param)
+        }
+
+    end
+
+    # Verify that objects can only have parents of the same type.
+    def test_validparent
+        parent = child1 = nil
+        children = []
+
+        # create the parent class
+        children << compobj("parent", :args => AST::ASTArray.new(:children => []))
+
+        # Create child class one
+        children << classobj("child1", :parentclass => nameobj("parent"))
+
+        # Now call the two classes
+        assert_nothing_raised("Could not add AST nodes for calling") {
+            children << AST::ObjectDef.new(
+                :type => nameobj("child1"),
+                :name => nameobj("yayness"),
+                :params => astarray()
+            )
+        }
+
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        scope = nil
+        assert_raise(Puppet::ParseError, "Invalid parent type was allowed") {
+            scope = Puppet::Parser::Scope.new()
+            objects = top.evaluate(scope)
+        }
+    end
+
+    # Verify that classes are correctly defined in node scopes.
+    def test_nodeclasslookup
+        parent = child1 = nil
+        children = []
+
+        # create the parent class
+        children << classobj("parent")
+
+        # Create child class one
+        children << classobj("child1", :parentclass => nameobj("parent"))
+
+        # Now call the two classes
+        assert_nothing_raised("Could not add AST nodes for calling") {
+            children << AST::ObjectDef.new(
+                :type => nameobj("child1"),
+                :name => nameobj("yayness"),
+                :params => astarray()
+            )
+        }
+
+        # create the node
+        nodename = "mynodename"
+        node = nil
+        assert_nothing_raised("Could not create parent object") {
+            node = AST::NodeDef.new(
+                :names => nameobj(nodename),
+                :code => AST::ASTArray.new(
+                    :children => children
+                )
+            )
+        }
+
+        # Create the wrapper object
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => [node]
+            )
+        }
+
+        # Evaluate the parse tree
+        scope = nil
+        assert_nothing_raised("Could not evaluate node") {
+            scope = Puppet::Parser::Scope.new()
+            top.evaluate(scope)
+        }
+
+        # Verify that, well, nothing really happened, and especially verify
+        # that the top scope is not a node scope
+        assert(scope.topscope?, "Scope is not top scope")
+        assert(! scope.nodescope?, "Scope is mistakenly node scope")
+        assert(! scope.lookupclass("parent"), "Found parent class in top scope")
+
+        # verify we can find our node
+        assert(scope.node(nodename), "Could not find node")
+
+        # And verify that we can evaluate it okay
+        objects = nil
+        assert_nothing_raised("Could not retrieve node definition") {
+            objects = scope.evalnode([nodename], {})
+        }
+        assert(objects, "Could not retrieve node definition")
+
+        # Because node scopes are temporary (i.e., they get destroyed after the node's
+        # config is returned) we should not be able to find the node scope.
+        nodescope = nil
+        assert_nothing_raised {
+            nodescope = scope.find { |child|
+                child.nodescope?
+            }
+        }
+
+        assert_nil(nodescope, "Found nodescope")
+
+        # And now verify again that the top scope cannot find the node's definition
+        # of the parent class
+        assert(! scope.lookupclass("parent"), "Found parent class in top scope")
+
+        # Verify that we can evaluate the node twice
+        assert_nothing_raised("Could not retrieve node definition") {
+            scope.evalnode([nodename], {})
+        }
+    end
+
+    # Test that you can look a host up using multiple names, e.g., an FQDN and
+    # a short name
+    def test_multiplenodenames
+        children = []
+
+        # create a short-name node
+        shortname = "mynodename"
+        children << nodeobj(shortname)
+
+        # And a long-name node
+        longname = "node.domain.com"
+        children << nodeobj(longname)
+
+        # Create the wrapper object
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        # Evaluate the parse tree
+        scope = nil
+        assert_nothing_raised("Could not evaluate node") {
+            scope = Puppet::Parser::Scope.new()
+            top.evaluate(scope)
+        }
+
+        # Verify we can find the node via a search list
+        objects = nil
+        assert_nothing_raised("Could not retrieve short node definition") {
+            objects = scope.evalnode(["%s.domain.com" % shortname, shortname], {})
+        }
+        assert(objects, "Could not retrieve short node definition")
+
+        # and then look for the long name
+        assert_nothing_raised("Could not retrieve long node definition") {
+            objects = scope.evalnode([longname.sub(/\..+/, ''), longname], {})
+        }
+        assert(objects, "Could not retrieve long node definition")
+    end
+
+    # Test that a node gets the entire configuration except for work meant for
+    # another node
+    def test_fullconfigwithnodes
+        children = []
+
+        children << fileobj("/testing")
+
+        # create a short-name node
+        name = "mynodename"
+        children << nodeobj(name)
+
+        # Create the wrapper object
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        # Evaluate the parse tree
+        scope = nil
+        assert_nothing_raised("Could not evaluate node") {
+            scope = Puppet::Parser::Scope.new()
+            top.evaluate(scope)
+        }
+
+        # 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], {})
+        }
+        assert(objects, "Could not retrieve short node definition")
+
+        # 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_nothing_raised("Could not find node-declared object") {
+            assert_equal("/%s" % name, objects[1][0][:name])
+        }
+    end
+
+    # Test that we can 'include' variables, not just normal strings.
+    def test_includevars
+        children = []
+
+        # Create our class for testin
+        klassname = "include"
+        children << classobj(klassname)
+
+        # Then add our variable assignment
+        children << varobj("klassvar", klassname)
+
+        # And finally add our calling of the variable
+        children << AST::ObjectDef.new(
+            :type => AST::Variable.new(:value => "klassvar"),
+            :params => astarray
+        )
+
+        # And then create our top object
+        top = AST::ASTArray.new(
+            :children => children
+        )
+
+        # Evaluate the parse tree
+        scope = nil
+        assert_nothing_raised("Could not evaluate node") {
+            scope = Puppet::Parser::Scope.new()
+            top.evaluate(scope)
+        }
+
+        # Verify we can find the node via a search list
+        objects = nil
+        assert_nothing_raised("Could not retrieve objects") {
+            objects = scope.to_trans
+        }
+        assert(objects, "Could not retrieve objects")
+
+        assert_nothing_raised("Could not find top-declared object") {
+            assert_equal("/%s" % klassname, objects[0][0][:name])
+        }
+    end
+
+    # Test that node inheritance works correctly
+    def test_znodeinheritance
+        children = []
+
+        # create the base node
+        name = "basenode"
+        children << nodeobj(name)
+
+        # and the sub node
+        name = "subnode"
+        children << AST::NodeDef.new(
+            :names => nameobj(name),
+            :parentclass => nameobj("basenode"),
+            :code => AST::ASTArray.new(
+                :children => [
+                    varobj("%svar" % name, "%svalue" % name),
+                    fileobj("/%s" % name)
+                ]
+            )
+        )
+        #subnode = nodeobj(name)
+        #subnode.parentclass = "basenode"
+
+        #children << subnode
+
+        # and the top object
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        # Evaluate the parse tree
+        scope = nil
+        assert_nothing_raised("Could not evaluate node") {
+            scope = Puppet::Parser::Scope.new()
+            top.evaluate(scope)
+        }
+
+        # Verify we can find the node via a search list
+        objects = nil
+        assert_nothing_raised("Could not retrieve node definition") {
+            objects = scope.evalnode([name], {})
+        }
+        assert(objects, "Could not retrieve node definition")
+
+        assert_nothing_raised {
+            inner = objects[0]
+
+            # 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])
+            }
+
+            # and the parent node file
+            assert_nothing_raised("Could not find subnode file") {
+                sub = inner[1]
+                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]
+                    )
+                }
+            }
+        }
+    end
+end