puppet 0.9.2

data/test/server/logger.rb

@@ -0,0 +1,175 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'test/unit'
+require 'puppettest.rb'
+require 'base64'
+require 'cgi'
+
+class TestLogger < Test::Unit::TestCase
+	include ServerTest
+
+    # Test the log driver manually
+    def test_localaddlog
+        logger = nil
+        assert_nothing_raised {
+            logger = Puppet::Server::Logger.new
+        }
+
+        msg = nil
+        assert_nothing_raised {
+            msg = Puppet::Log.create(
+                :level => :info,
+                :message => "This is a message"
+            )
+        }
+
+        assert_nothing_raised {
+            logger.addlog(msg)
+        }
+    end
+
+    # Test it while replicating a remote client
+    def test_remoteaddlog
+        logger = nil
+        assert_nothing_raised {
+            logger = Puppet::Server::Logger.new
+        }
+
+        msg = nil
+        assert_nothing_raised {
+            msg = Puppet::Log.create(
+                :level => :info,
+                :message => "This is a remote message"
+            )
+        }
+
+        assert_nothing_raised {
+            msg = CGI.escape(Marshal::dump(msg))
+        }
+        assert_nothing_raised {
+            logger.addlog(msg, "localhost", "127.0.0.1")
+        }
+    end
+
+    # Now test it with a real client and server, but not remote
+    def test_localclient
+        client = nil
+        assert_nothing_raised {
+            client = Puppet::Client::LogClient.new(:Logger => true)
+        }
+
+        msg = nil
+        assert_nothing_raised {
+            msg = Puppet::Log.create(
+                :level => :info,
+                :message => "This is a logclient message"
+            )
+        }
+
+        msg = CGI.escape(Marshal::dump(msg))
+
+        assert_nothing_raised {
+            client.addlog(msg, "localhost", "127.0.0.1")
+        }
+    end
+
+    # And now test over the network
+    def test_logclient
+        pid = nil
+        clientlog = tempfile()
+        serverlog = tempfile()
+        Puppet.warning "serverlog is %s" % serverlog
+        Puppet[:logdest] = clientlog
+        Puppet::Log.close(:syslog)
+
+        # For testing
+        Puppet[:autosign] = true
+
+        logger = nil
+        # Create our server
+        assert_nothing_raised {
+            logger = Puppet::Server.new(
+                :Port => @@port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Logger => {}
+                }
+            )
+        }
+
+        # Start our server
+        serverpid = fork {
+            Puppet::Log.close(clientlog)
+            Puppet[:logdest] = serverlog
+            assert_nothing_raised() {
+                trap(:INT) { logger.shutdown }
+                logger.start
+            }
+        }
+        @@tmppids << serverpid
+        sleep(0.5)
+
+        # Start a raw xmlrpc client
+        client = nil
+        assert_nothing_raised() {
+            client = Puppet::Client::LogClient.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+            unless client.readcert
+                raise "Could not get certs"
+            end
+        }
+        retval = nil
+
+        {
+            :notice => "XMLRPC1",
+            :warning => "XMLRPC2",
+            :err => "XMLRPC3"
+        }.each { |level, str|
+            msg = CGI.escape(Marshal::dump(Puppet::Log.create(
+                :level => level,
+                :message => str
+            )))
+            assert_nothing_raised {
+                retval = client.addlog(msg)
+            }
+        }
+
+        # and now use the normal client action
+
+        # Set the log destination to be the server
+        Puppet[:logdest] = "localhost:%s" % @@port
+
+        # And now do some logging
+        assert_nothing_raised {
+            Puppet.notice "TEST1"
+            Puppet.warning "TEST2"
+            Puppet.err "TEST3"
+        }
+
+        assert_nothing_raised {
+            Process.kill("INT", serverpid)
+        }
+
+        assert(FileTest.exists?(serverlog), "Server log does not exist")
+
+        # Give it a bit to flush to disk
+        sleep(0.5)
+        content = nil
+        assert_nothing_raised {
+            content = File.read(serverlog)
+        }
+
+        %w{TEST1 TEST2 TEST3}.each { |str|
+            assert(content =~ %r{#{str}}, "Content does not match %s" % str)
+        }
+    end
+end
+
+# $Id: logger.rb 751 2005-11-22 05:54:25Z luke $

data/test/server/master.rb

@@ -0,0 +1,150 @@
+if __FILE__ == $0
+    if Dir.getwd =~ /test\/server$/
+        Dir.chdir("..")
+    end
+
+    $:.unshift '../lib'
+    $puppetbase = ".."
+
+end
+
+require 'puppet'
+require 'puppet/server'
+require 'puppet/client'
+require 'test/unit'
+require 'puppettest.rb'
+
+class TestMaster < Test::Unit::TestCase
+	include ServerTest
+    def teardown
+        super
+        #print "\n\n\n\n" if Puppet[:debug]
+    end
+
+    # run through all of the existing test files and make sure everything
+    # works
+    def test_files
+        count = 0
+        textfiles { |file|
+            Puppet.debug("parsing %s" % file)
+            client = nil
+            master = nil
+
+            # create our master
+            assert_nothing_raised() {
+                # this is the default server setup
+                master = Puppet::Server::Master.new(
+                    :File => file,
+                    :UseNodes => false,
+                    :Local => true
+                )
+            }
+
+            # and our client
+            assert_nothing_raised() {
+                client = Puppet::Client::MasterClient.new(
+                    :Master => master
+                )
+            }
+
+            # pull our configuration a few times
+            assert_nothing_raised() {
+                client.getconfig
+                stopservices
+                Puppet::Type.allclear
+            }
+            assert_nothing_raised() {
+                client.getconfig
+                stopservices
+                Puppet::Type.allclear
+            }
+            assert_nothing_raised() {
+                client.getconfig
+                stopservices
+                Puppet::Type.allclear
+            }
+            # only test three files; that's plenty
+            if count > 3
+                break
+            end
+            count += 1
+        }
+    end
+
+    def test_defaultmanifest
+        textfiles { |file|
+            Puppet[:manifest] = file
+            client = nil
+            master = nil
+            assert_nothing_raised() {
+                # this is the default server setup
+                master = Puppet::Server::Master.new(
+                    :File => file,
+                    :UseNodes => false,
+                    :Local => true
+                )
+            }
+            assert_nothing_raised() {
+                client = Puppet::Client::MasterClient.new(
+                    :Master => master
+                )
+            }
+
+            # pull our configuration
+            assert_nothing_raised() {
+                client.getconfig
+                stopservices
+                Puppet::Type.allclear
+            }
+
+            break
+        }
+    end
+
+    def test_filereread
+        manifest = mktestmanifest()
+
+        file2 = @createdfile + "2"
+        @@tmpfiles << file2
+
+        client = master = nil
+        assert_nothing_raised() {
+            # this is the default server setup
+            master = Puppet::Server::Master.new(
+                :File => manifest,
+                :UseNodes => false,
+                :Local => true,
+                :FileTimeout => 0.5
+            )
+        }
+        assert_nothing_raised() {
+            client = Puppet::Client::MasterClient.new(
+                :Master => master
+            )
+        }
+
+        assert_nothing_raised {
+            client.getconfig
+            client.apply
+        }
+
+        assert(FileTest.exists?(@createdfile),
+            "Created file %s does not exist" % @createdfile)
+        sleep 1
+        Puppet::Type.allclear
+
+        File.open(manifest, "w") { |f|
+            f.puts "file { \"%s\": create => true }\n" % file2
+        }
+        assert_nothing_raised {
+            client.getconfig
+            client.apply
+        }
+
+        assert(FileTest.exists?(file2), "Second file %s does not exist" % file2)
+    end
+
+end
+
+# $Id: master.rb 751 2005-11-22 05:54:25Z luke $
+

data/test/server/server.rb

@@ -0,0 +1,130 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'cgi'
+#require 'puppet/server'
+require 'facter'
+require 'puppet/client'
+require 'xmlrpc/client'
+require 'test/unit'
+require 'puppettest.rb'
+
+# $Id: server.rb 747 2005-11-22 03:54:30Z luke $
+
+if ARGV.length > 0 and ARGV[0] == "short"
+    $short = true
+else
+    $short = false
+end
+
+class TestServer < Test::Unit::TestCase
+	include ServerTest
+    def teardown
+        super
+        #print "\n\n\n\n" if Puppet[:debug]
+    end
+
+    # test that we can connect to the server
+    # we have to use fork here, because we apparently can't use threads
+    # to talk to other threads
+    def test_connect_with_fork
+        server = nil
+        Puppet[:autosign] = true
+
+        # create a server just serving status
+        assert_nothing_raised() {
+            server = Puppet::Server.new(
+                :Port => @@port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Status => nil
+                }
+            )
+
+        }
+
+        # and fork
+        serverpid = fork {
+            assert_nothing_raised() {
+                trap(:INT) { server.shutdown }
+                server.start
+            }
+        }
+        @@tmppids << serverpid
+
+        # create a status client, and verify it can talk
+        client = nil
+        assert_nothing_raised() {
+            client = Puppet::Client::StatusClient.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+        }
+        retval = nil
+
+        assert_nothing_raised() {
+            retval = client.status
+        }
+
+        assert_equal(1, retval)
+    end
+
+    # similar to the last test, but this time actually run getconfig
+    def test_getconfig_with_fork
+        Puppet[:autosign] = true
+        serverpid = nil
+
+        file = mktestmanifest()
+
+        server = nil
+        # make our server again
+        assert_nothing_raised() {
+            server = Puppet::Server.new(
+                :Port => @@port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Master => {
+                        :UseNodes => false,
+                        :File => file
+                    },
+                    :Status => nil
+                }
+            )
+
+        }
+        serverpid = fork {
+            assert_nothing_raised() {
+                #trap(:INT) { server.shutdown; Kernel.exit! }
+                trap(:INT) { server.shutdown }
+                server.start
+            }
+        }
+        @@tmppids << serverpid
+
+        client = nil
+
+        # and then start a masterclient
+        assert_nothing_raised() {
+            client = Puppet::Client::MasterClient.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+        }
+        retval = nil
+
+        # and run getconfig a couple of times
+        assert_nothing_raised() {
+            retval = client.getconfig
+        }
+        assert_instance_of(Puppet::TransBucket, retval,
+            "Server returned something other than a TransBucket")
+
+        assert_nothing_raised() {
+            retval = client.getconfig
+        }
+    end
+end