Moving all files into a consolidated trunk. All tests pass except the known-failing certificate test, but there appear to be some errors that are incorrectly not resulting in failurs. I will track those down ASAP.

git-svn-id: https://reductivelabs.com/svn/puppet/trunk@576 980ebf18-57e1-0310-9a29-db15c13687c0

4 files changed, 1110 insertions, 0 deletions

diff --git a/test/server/tc_ca.rb b/test/server/tc_ca.rb
new file mode 100644
index 000000000..9fb579638
--- /dev/null
+++ b/test/server/tc_ca.rb
@@ -0,0 +1,225 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '../../../../library/trunk/lib/'
+    $:.unshift '../../../../library/trunk/test/'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/ca'
+require 'puppet/sslcertificates'
+require 'openssl'
+require 'test/unit'
+require 'puppettest.rb'
+
+# $Id$
+
+if ARGV.length > 0 and ARGV[0] == "short"
+    $short = true
+else
+    $short = false
+end
+
+class TestCA < Test::Unit::TestCase
+    def setup
+        if __FILE__ == $0
+            Puppet[:loglevel] = :debug
+            #paths = Puppet::Type.type(:service).searchpath
+            #paths.push "%s/examples/root/etc/init.d" % $puppetbase
+            #Puppet::Type.type(:service).setpath(paths)
+        end
+
+        @@tmpfiles = []
+    end
+
+    def teardown
+        Puppet::Type.allclear
+        print "\n\n" if Puppet[:debug]
+
+        @@tmpfiles.each { |file|
+            if FileTest.exists?(file)
+                system("rm -rf %s" % file)
+            end
+        }
+    end
+
+    def test_autocertgeneration
+        ssldir = "/tmp/testcertdir"
+        @@tmpfiles.push ssldir
+        assert_nothing_raised {
+            Puppet[:autosign] = true
+            Puppet[:ssldir] = ssldir
+        }
+        file = File.join($puppetbase, "examples", "code", "head")
+        ca = nil
+
+        assert_nothing_raised {
+            ca = Puppet::CA.new()
+        }
+
+        key = nil
+        csr = nil
+        cert = nil
+        hostname = "test.domain.com"
+        assert_nothing_raised {
+            cert = Puppet::SSLCertificates::Certificate.new(
+                :name => "test.domain.com"
+            )
+        }
+        assert_nothing_raised {
+            cert.mkcsr
+        }
+
+        certtext = nil
+        cacerttext = nil
+        assert_nothing_raised {
+            certtext, cacerttext = ca.getcert(cert.csr.to_s)
+        }
+
+        assert_instance_of(String, certtext)
+        assert_instance_of(String, cacerttext)
+        x509 = nil
+        assert_nothing_raised {
+            x509 = OpenSSL::X509::Certificate.new(certtext)
+        }
+        assert_nothing_raised {
+            OpenSSL::X509::Certificate.new(cacerttext)
+        }
+
+        # and pull it again, just to make sure we're getting the same thing
+        newtext = nil
+        assert_nothing_raised {
+            newtext, cacerttext = ca.getcert(cert.csr.to_s)
+        }
+
+        assert_equal(certtext,newtext)
+    end
+
+    def test_storeAndSign
+        ssldir = "/tmp/testcertdir"
+        @@tmpfiles.push ssldir
+        assert_nothing_raised {
+            Puppet[:ssldir] = ssldir
+            Puppet[:autosign] = false
+        }
+        file = File.join($puppetbase, "examples", "code", "head")
+        ca = nil
+        caserv = nil
+        assert_nothing_raised {
+            caserv = Puppet::CA.new()
+        }
+        assert_nothing_raised {
+            ca = caserv.ca
+        }
+
+        key = nil
+        csr = nil
+        cert = nil
+        hostname = "test.domain.com"
+        assert_nothing_raised {
+            cert = Puppet::SSLCertificates::Certificate.new(
+                :name => "anothertest.domain.com"
+            )
+        }
+        assert_nothing_raised {
+            cert.mkcsr
+        }
+
+        certtext = nil
+        assert_nothing_raised {
+            certtext, cacerttext = caserv.getcert(cert.csr.to_s)
+        }
+
+        assert_equal("", certtext)
+
+        x509 = nil
+        assert_nothing_raised {
+            x509, cacert = ca.sign(cert.csr)
+        }
+        cert.cert = x509
+        assert_nothing_raised {
+            cert.write
+        }
+
+        assert(File.exists?(cert.certfile))
+
+        newtext = nil
+        assert_nothing_raised {
+            newtext, cacerttext  = caserv.getcert(cert.csr.to_s)
+        }
+
+        assert(newtext)
+    end
+
+    def cycleautosign
+        ssldir = "/tmp/testcertdir"
+        autosign = "/tmp/autosign"
+        @@tmpfiles.push ssldir
+        @@tmpfiles.push autosign
+        assert_nothing_raised {
+            Puppet[:ssldir] = ssldir
+        }
+        file = File.join($puppetbase, "examples", "code", "head")
+        caserv = nil
+
+        assert_nothing_raised {
+            caserv = Puppet::CA.new()
+        }
+
+        key = nil
+        csr = nil
+        cert = nil
+        hostname = "test.domain.com"
+        assert_nothing_raised {
+            cert = Puppet::SSLCertificates::Certificate.new(
+                :name => "test.domain.com"
+            )
+        }
+        assert_nothing_raised {
+            cert.mkcsr
+        }
+
+        certtext = nil
+        assert_nothing_raised {
+            certtext = caserv.getcert(cert.csr.to_s)
+        }
+
+        x509 = nil
+        assert_nothing_raised {
+            x509 = OpenSSL::X509::Certificate.new(certtext)
+        }
+
+        assert(File.exists?(cert.certfile))
+
+        newtext = nil
+        assert_nothing_raised {
+            newtext = caserv.getcert(cert.csr.to_s)
+        }
+
+        assert_equal(certtext,newtext)
+    end
+
+    def test_autosign
+        autosign = "/tmp/autosign"
+        Puppet[:autosign] = "/tmp/autosign"
+        @@tmpfiles << autosign
+        File.open(autosign, "w") { |f|
+            f.puts "hostmatch.domain.com"
+            f.puts ".+.other.com"
+            f.puts "hostname.+"
+        }
+
+        caserv = nil
+        file = File.join($puppetbase, "examples", "code", "head")
+        assert_nothing_raised {
+            caserv = Puppet::CA.new()
+        }
+
+        assert(caserv.autosign?("hostmatch.domain.com"))
+        assert(caserv.autosign?("fakehost.other.com"))
+        assert(caserv.autosign?("hostname.rahtest.boo"))
+        assert(caserv.autosign?("hostname.com")) # a tricky one
+        assert(!caserv.autosign?("kirby.reductivelabs.com"))
+        assert(!caserv.autosign?("culain.domain.com"))
+    end
+end
diff --git a/test/server/tc_fileserver.rb b/test/server/tc_fileserver.rb
new file mode 100755
index 000000000..ad9b6298c
--- /dev/null
+++ b/test/server/tc_fileserver.rb
@@ -0,0 +1,386 @@
+if __FILE__ == $0
+    if Dir.getwd =~ /test\/server$/
+        Dir.chdir("..")
+    end
+
+    $:.unshift '../lib'
+    $:.unshift '../../../library/trunk/lib/'
+    $:.unshift '../../../library/trunk/test/'
+    $puppetbase = ".."
+
+end
+
+require 'puppet'
+require 'puppet/fileserver'
+require 'test/unit'
+require 'puppettest.rb'
+
+class TestFileServer < TestPuppet
+    def setup
+        if __FILE__ == $0
+            Puppet[:loglevel] = :debug
+        end
+
+        super
+    end
+
+    def mkrandomdirs(dir, depth, width)
+        assert_nothing_raised {
+            Dir.mkdir(dir)
+        }
+
+    end
+
+    def test_namefailures
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::FileServer.new(
+                :Local => true
+            )
+        }
+
+        assert_raise(Puppet::FileServerError) {
+            server.mount("/tmp", "invalid+name")
+        }
+
+        assert_raise(Puppet::FileServerError) {
+            server.mount("/tmp", "invalid-name")
+        }
+
+        assert_raise(Puppet::FileServerError) {
+            server.mount("/tmp", "invalid name")
+        }
+
+        assert_raise(Puppet::FileServerError) {
+            server.mount("/tmp", "")
+        }
+    end
+
+    def test_listroot
+        server = nil
+        testdir = "/tmp/remotefilecopying"
+        tmpfile = File.join(testdir, "tmpfile")
+        assert_nothing_raised {
+            Dir.mkdir(testdir)
+            File.open(tmpfile, "w") { |f|
+                3.times { f.puts rand(100) }
+            }
+            @@tmpfiles << testdir
+        }
+
+        file = nil
+        checks = Puppet::FileServer::CHECKPARAMS
+
+        assert_nothing_raised {
+            server = Puppet::FileServer.new(
+                :Local => true
+            )
+        }
+
+        assert_nothing_raised {
+            server.mount(testdir, "test")
+        }
+
+        list = nil
+        assert_nothing_raised {
+            list = server.list("/test/", true)
+        }
+
+        assert(list =~ /tmpfile/)
+
+        assert_nothing_raised {
+            list = server.list("/test", true)
+        }
+        assert(list =~ /tmpfile/)
+
+    end
+
+    def test_getfilelist
+        server = nil
+        testdir = "/tmp/remotefilecopying"
+        #subdir = "testingyo"
+        #subpath = File.join(testdir, "testingyo")
+        #dir = File.join(testdir, subdir)
+        tmpfile = File.join(testdir, "tmpfile")
+        assert_nothing_raised {
+            Dir.mkdir(testdir)
+            #Dir.mkdir(subpath)
+            File.open(tmpfile, "w") { |f|
+                3.times { f.puts rand(100) }
+            }
+            @@tmpfiles << testdir
+        }
+
+        file = nil
+
+        assert_nothing_raised {
+            server = Puppet::FileServer.new(
+                :Local => true
+            )
+        }
+
+        assert_nothing_raised {
+            server.mount(testdir, "test")
+        }
+
+        list = nil
+        sfile = "/test/tmpfile"
+        assert_nothing_raised {
+            list = server.list(sfile, true)
+        }
+
+        assert_nothing_raised {
+            file = Puppet::Type::PFile[tmpfile]
+        }
+
+        output = "/\tfile"
+
+        assert_equal(output, list)
+        assert(list !~ /\t\t/)
+
+        list.split("\n").each { |line|
+            assert(line !~ %r{remotefile})
+        }
+        contents = File.read(tmpfile)
+
+        ret = nil
+        assert_nothing_raised {
+            ret = server.retrieve(sfile)
+        }
+
+        assert_equal(contents, ret)
+    end
+
+    def test_seenewfiles
+        server = nil
+        testdir = "/tmp/remotefilecopying"
+        oldfile = File.join(testdir, "oldfile")
+        newfile = File.join(testdir, "newfile")
+        assert_nothing_raised {
+            Dir.mkdir(testdir)
+            File.open(oldfile, "w") { |f|
+                3.times { f.puts rand(100) }
+            }
+            @@tmpfiles << testdir
+        }
+
+        file = nil
+        checks = Puppet::FileServer::CHECKPARAMS
+
+        assert_nothing_raised {
+            server = Puppet::FileServer.new(
+                :Local => true
+            )
+        }
+
+        assert_nothing_raised {
+            server.mount(testdir, "test")
+        }
+
+        list = nil
+        sfile = "/test/"
+        assert_nothing_raised {
+            list = server.list(sfile, true)
+        }
+
+        File.open(newfile, "w") { |f|
+            3.times { f.puts rand(100) }
+        }
+
+        newlist = nil
+        assert_nothing_raised {
+            newlist = server.list(sfile, true)
+        }
+
+        assert(list != newlist)
+
+        assert(newlist =~ /newfile/)
+    end
+
+    def test_mountroot
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::FileServer.new(
+                :Local => true
+            )
+        }
+
+        assert_nothing_raised {
+            server.mount("/", "root")
+        }
+
+        testdir = "/tmp/remotefilecopying"
+        oldfile = File.join(testdir, "oldfile")
+        assert_nothing_raised {
+            Dir.mkdir(testdir)
+            File.open(oldfile, "w") { |f|
+                3.times { f.puts rand(100) }
+            }
+            @@tmpfiles << testdir
+        }
+
+        list = nil
+        assert_nothing_raised {
+            list = server.list("/root/" + testdir, true)
+        }
+
+        assert(list =~ /oldfile/)
+    end
+
+    def test_recursionlevels
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::FileServer.new(
+                :Local => true
+            )
+        }
+
+        basedir = "/tmp/remotefilecopying"
+        testdir = "%s/with/some/sub/directories/for/the/purposes/of/testing" % basedir
+        oldfile = File.join(testdir, "oldfile")
+        assert_nothing_raised {
+            system("mkdir -p %s" % testdir)
+            File.open(oldfile, "w") { |f|
+                3.times { f.puts rand(100) }
+            }
+            @@tmpfiles << basedir
+        }
+
+        assert_nothing_raised {
+            server.mount(basedir, "test")
+        }
+
+        list = nil
+        assert_nothing_raised {
+            list = server.list("/test/with", false)
+        }
+
+        assert(list !~ /\n/)
+
+        [0, 1, 2].each { |num|
+            assert_nothing_raised {
+                list = server.list("/test/with", num)
+            }
+
+            count = 0
+            #p list
+            while list =~ /\n/
+                list.sub!(/\n/, '')
+                count += 1
+            end
+            assert_equal(num, count)
+        }
+    end
+
+    def test_listedpath
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::FileServer.new(
+                :Local => true
+            )
+        }
+
+        basedir = "/tmp/remotefilecopying"
+        testdir = "%s/with/some/sub/directories/for/testing" % basedir
+        oldfile = File.join(testdir, "oldfile")
+        assert_nothing_raised {
+            system("mkdir -p %s" % testdir)
+            File.open(oldfile, "w") { |f|
+                3.times { f.puts rand(100) }
+            }
+            @@tmpfiles << basedir
+        }
+
+        assert_nothing_raised {
+            server.mount(basedir, "localhost")
+        }
+
+        list = nil
+        assert_nothing_raised {
+            list = server.list("/localhost/with", false)
+        }
+
+        assert(list !~ /with/)
+
+        assert_nothing_raised {
+            list = server.list("/localhost/with/some/sub", true)
+        }
+
+        assert(list !~ /sub/)
+    end
+
+    def test_widelists
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::FileServer.new(
+                :Local => true
+            )
+        }
+
+        basedir = "/tmp/remotefilecopying"
+        dirs = %w{a set of directories}
+        assert_nothing_raised {
+            Dir.mkdir(basedir)
+            dirs.each { |dir|
+                Dir.mkdir(File.join(basedir, dir))
+            }
+            @@tmpfiles << basedir
+        }
+
+        assert_nothing_raised {
+            server.mount(basedir, "localhost")
+        }
+
+        list = nil
+        assert_nothing_raised {
+            list = server.list("/localhost/", 1).split("\n")
+        }
+
+        assert_equal(dirs.length + 1, list.length)
+    end
+
+    def test_describe
+        server = nil
+        testdir = "/tmp/remotefilecopying"
+        assert_nothing_raised {
+            Dir.mkdir(testdir)
+            @@tmpfiles << testdir
+            %w{a b c d e}.each { |l|
+                name = File.join(testdir, "file%s" % name)
+                File.open(name, "w") { |f|
+                    f.puts rand(100)
+                }
+            }
+        }
+
+        file = nil
+        checks = Puppet::FileServer::CHECKPARAMS
+
+        assert_nothing_raised {
+            server = Puppet::FileServer.new(
+                :Local => true
+            )
+        }
+
+        assert_nothing_raised {
+            server.mount(testdir, "test")
+        }
+
+        list = nil
+        sfile = "/test/"
+        assert_nothing_raised {
+            list = server.list(sfile, true)
+        }
+
+        assert_nothing_raised {
+            list.split("\n").each { |line|
+                file, type = line.split("\t")
+
+                desc = server.describe(sfile + file)
+            }
+        }
+    end
+end
+
+# $Id$
+
diff --git a/test/server/tc_master.rb b/test/server/tc_master.rb
new file mode 100644
index 000000000..be61b232b
--- /dev/null
+++ b/test/server/tc_master.rb
@@ -0,0 +1,135 @@
+if __FILE__ == $0
+    if Dir.getwd =~ /test\/server$/
+        Dir.chdir("..")
+        #puts "Unfortunately, you must be in the test dir to run this test."
+        #puts "Yes, I know it's different than all of the others."
+        #exit
+    end
+
+    $:.unshift '../lib'
+    $:.unshift '../../../library/trunk/lib/'
+    $:.unshift '../../../library/trunk/test/'
+    $puppetbase = ".."
+
+end
+
+#if __FILE__ == $0
+#    $:.unshift '../../lib'
+#    $:.unshift '../../../../library/trunk/lib/'
+#    $:.unshift '../../../../library/trunk/test/'
+#    $puppetbase = "../.."
+#end
+
+require 'puppet'
+require 'puppet/master'
+require 'puppet/client'
+require 'test/unit'
+require 'puppettest.rb'
+
+class TestMaster < Test::Unit::TestCase
+    def setup
+        if __FILE__ == $0
+            Puppet[:loglevel] = :debug
+        end
+
+        @@tmpfiles = []
+    end
+
+    def stopservices
+        if stype = Puppet::Type.type(:service)
+            stype.each { |service|
+                service[:running] = false
+                service.sync
+            }
+        end
+    end
+
+    def teardown
+        Puppet::Type.allclear
+        print "\n\n\n\n" if Puppet[:debug]
+
+        @@tmpfiles.each { |file|
+            if FileTest.exists?(file)
+                system("rm -rf %s" % file)
+            end
+        }
+    end
+
+    def test_files
+        Puppet[:debug] = true if __FILE__ == $0
+        Puppet[:puppetconf] = "/tmp/servertestingdir"
+        @@tmpfiles << Puppet[:puppetconf]
+        textfiles { |file|
+            Puppet.debug("parsing %s" % file)
+            server = nil
+            client = nil
+            threads = []
+            port = 8080
+            master = nil
+            assert_nothing_raised() {
+                # this is the default server setup
+                master = Puppet::Master.new(
+                    :File => file,
+                    :Local => true
+                )
+            }
+            assert_nothing_raised() {
+                client = Puppet::Client.new(
+                    :Server => master
+                )
+            }
+
+            # pull our configuration
+            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
+            }
+        }
+    end
+
+    def test_defaultmanifest
+        Puppet[:debug] = true if __FILE__ == $0
+        Puppet[:puppetconf] = "/tmp/servertestingdir"
+        @@tmpfiles << Puppet[:puppetconf]
+        textfiles { |file|
+            Puppet[:manifest] = file
+            client = nil
+            master = nil
+            assert_nothing_raised() {
+                # this is the default server setup
+                master = Puppet::Master.new(
+                    :File => file,
+                    :Local => true
+                )
+            }
+            assert_nothing_raised() {
+                client = Puppet::Client.new(
+                    :Server => master
+                )
+            }
+
+            # pull our configuration
+            assert_nothing_raised() {
+                client.getconfig
+                stopservices
+                Puppet::Type.allclear
+            }
+
+            break
+        }
+    end
+end
+
+# $Id$
+
diff --git a/test/server/tc_server.rb b/test/server/tc_server.rb
new file mode 100644
index 000000000..d3a4ea305
--- /dev/null
+++ b/test/server/tc_server.rb
@@ -0,0 +1,364 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '../../../../library/trunk/lib/'
+    $:.unshift '../../../../library/trunk/test/'
+    $puppetbase = "../.."
+end
+#if __FILE__ == $0
+#    $:.unshift '../lib'
+#    $:.unshift '../../../library/trunk/lib/'
+#    $:.unshift '../../../library/trunk/test/'
+#    $puppetbase = ".."
+#
+#
+#    if Dir.getwd !~ /test$/
+#        puts "Unfortunately, you must be in the test dir to run this test."
+#        puts "Yes, I know it's different than all of the others."
+#        exit
+#    end
+#end
+
+require 'puppet'
+require 'cgi'
+require 'puppet/server'
+require 'facter'
+require 'puppet/client'
+require 'xmlrpc/client'
+require 'test/unit'
+require 'puppettest.rb'
+
+# $Id$
+
+if ARGV.length > 0 and ARGV[0] == "short"
+    $short = true
+else
+    $short = false
+end
+
+class TestServer < Test::Unit::TestCase
+    def setup
+        if __FILE__ == $0
+            Puppet[:loglevel] = :debug
+            #paths = Puppet::Type.type(:service).searchpath
+            #paths.push "%s/examples/root/etc/init.d" % $puppetbase
+            #Puppet::Type.type(:service).setpath(paths)
+        end
+
+        @@tmpfiles = []
+        @@tmppids = []
+    end
+
+    def stopservices
+        if stype = Puppet::Type.type(:service)
+            stype.each { |service|
+                service[:running] = false
+                service.sync
+            }
+        end
+    end
+
+    def teardown
+        Puppet::Type.allclear
+        print "\n\n\n\n" if Puppet[:debug]
+
+        @@tmpfiles.each { |file|
+            if FileTest.exists?(file)
+                system("rm -rf %s" % file)
+            end
+        }
+        @@tmppids.each { |pid|
+            system("kill -INT %s" % pid)
+        }
+    end
+
+    def test_start
+        server = nil
+        Puppet[:ssldir] = "/tmp/serverstarttesting"
+        Puppet[:autosign] = true
+        @@tmpfiles << "/tmp/serverstarttesting"
+        port = 8081
+        file = File.join($puppetbase, "examples", "code", "head")
+        assert_nothing_raised() {
+            server = Puppet::Server.new(
+                :Port => port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Master => {
+                        :File => file,
+                    },
+                    :Status => nil
+                }
+            )
+
+        }
+        sthread = nil
+        assert_nothing_raised() {
+            trap(:INT) { server.shutdown }
+            sthread = Thread.new {
+                server.start
+            }
+        }
+        sleep 1
+        assert_nothing_raised {
+            server.shutdown
+        }
+        assert_nothing_raised {
+            sthread.join
+        }
+    end
+
+    # disabled because i can't find a good way to test client connecting
+    # i'll have to test the external executables
+    def disabled_test_connect_with_threading
+        server = nil
+        Puppet[:ssldir] = "/tmp/serverconnecttesting"
+        Puppet[:autosign] = true
+        @@tmpfiles << "/tmp/serverconnecttesting"
+        threads = []
+        port = 8080
+        server = nil
+        Thread.abort_on_exception = true
+        assert_nothing_raised() {
+            server = Puppet::Server.new(
+                :Port => port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Status => nil
+                }
+            )
+
+        }
+        sthread = Thread.new {
+            assert_nothing_raised() {
+                #trap(:INT) { server.shutdown; Kernel.exit! }
+                trap(:INT) { server.shutdown }
+                server.start
+            }
+        }
+
+        sleep(3)
+        client = nil
+        assert_nothing_raised() {
+            client = XMLRPC::Client.new("localhost", "/RPC2", port, nil, nil,
+                nil, nil, true, 3)
+        }
+        retval = nil
+
+        clthread = Thread.new {
+            assert_nothing_raised() {
+                Puppet.notice "calling status"
+                retval = client.call("status.status", "")
+            }
+        }
+        assert_not_nil(clthread.join(5))
+
+        assert_equal(1, retval)
+        assert_nothing_raised {
+            #system("kill -INT %s" % serverpid)
+            server.shutdown
+        }
+
+        assert_not_nil(sthread.join(5))
+
+        #Process.wait
+    end
+
+    # disabled because i can't find a good way to test client connecting
+    # i'll have to test the external executables
+    def test_connect_with_fork
+        server = nil
+        Puppet[:ssldir] = "/tmp/serverconnecttesting"
+        Puppet[:autosign] = true
+        @@tmpfiles << "/tmp/serverconnecttesting"
+        serverpid = nil
+        port = 8080
+        assert_nothing_raised() {
+            server = Puppet::Server.new(
+                :Port => port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Status => nil
+                }
+            )
+
+        }
+        serverpid = fork {
+            assert_nothing_raised() {
+                #trap(:INT) { server.shutdown; Kernel.exit! }
+                trap(:INT) { server.shutdown }
+                server.start
+            }
+        }
+        @@tmppids << serverpid
+
+        sleep(3)
+        client = nil
+        assert_nothing_raised() {
+            client = XMLRPC::Client.new("localhost", "/RPC2", port, nil, nil,
+                nil, nil, true, 3)
+        }
+        retval = nil
+
+        assert_nothing_raised() {
+            Puppet.notice "calling status"
+            retval = client.call("status.status")
+        }
+
+        assert_equal(1, retval)
+        #assert_nothing_raised {
+        #    system("kill -INT %s" % serverpid)
+        #    #server.shutdown
+        #}
+
+        #Process.wait
+    end
+
+    # disabled because i can't find a good way to test client connecting
+    # i'll have to test the external executables
+    def test_zzgetconfig_with_fork
+        server = nil
+        Puppet[:ssldir] = "/tmp/serverconfigtesting"
+        Puppet[:autosign] = true
+        @@tmpfiles << "/tmp/serverconfigtesting"
+        serverpid = nil
+        port = 8082
+        file = File.join($puppetbase, "examples", "code", "head")
+        assert_nothing_raised() {
+            server = Puppet::Server.new(
+                :Port => port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Master => {
+                        :File => file
+                    },
+                    :Status => nil
+                }
+            )
+
+        }
+        serverpid = fork {
+            assert_nothing_raised() {
+                #trap(:INT) { server.shutdown; Kernel.exit! }
+                trap(:INT) { server.shutdown }
+                server.start
+            }
+        }
+        @@tmppids << serverpid
+
+        sleep(3)
+        client = nil
+
+        # first use a puppet client object
+        assert_nothing_raised() {
+            client = Puppet::Client.new(
+                :Server => "localhost",
+                :Port => port
+            )
+        }
+        retval = nil
+
+        assert_nothing_raised() {
+            Puppet.notice "calling status"
+            retval = client.getconfig
+        }
+
+        # then use a raw rpc client
+        assert_nothing_raised() {
+            client = XMLRPC::Client.new("localhost", "/RPC2", port, nil, nil,
+                nil, nil, true, 3)
+        }
+        retval = nil
+
+        facts = CGI.escape(Marshal.dump(Puppet::Client.facts))
+        assert_nothing_raised() {
+            Puppet.notice "calling status"
+            retval = client.call("puppetmaster.getconfig", facts)
+        }
+
+        #assert_equal(1, retval)
+    end
+
+    # disabled because clients can't seem to connect from in the same process
+    def disabled_test_files
+        Puppet[:debug] = true if __FILE__ == $0
+        Puppet[:puppetconf] = "/tmp/servertestingdir"
+        Puppet[:autosign] = true
+        @@tmpfiles << Puppet[:puppetconf]
+        textfiles { |file|
+            Puppet.debug("parsing %s" % file)
+            server = nil
+            client = nil
+            threads = []
+            port = 8080
+            assert_nothing_raised() {
+                # this is the default server setup
+                server = Puppet::Server.new(
+                    :Port => port,
+                    :Handlers => {
+                        :CA => {}, # so that certs autogenerate
+                        :Master => {
+                            :File => file,
+                        },
+                    }
+                )
+            }
+            assert_nothing_raised() {
+                client = Puppet::Client.new(
+                    :Server => "localhost",
+                    :Port => port
+                )
+            }
+
+            # start the server
+            assert_nothing_raised() {
+                trap(:INT) { server.shutdown }
+                threads << Thread.new {
+                    server.start
+                }
+            }
+
+            # start the client
+            #assert_nothing_raised() {
+            #    threads << Thread.new {
+            #        client.start
+            #    }
+            #}
+
+            sleep(1)
+            # pull our configuration
+            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
+            }
+
+            # and shut them both down
+            assert_nothing_raised() {
+                [server].each { |thing|
+                    thing.shutdown
+                }
+            }
+
+            # make sure everything's complete before we stop
+            assert_nothing_raised() {
+                threads.each { |thr|
+                    thr.join
+                }
+            }
+            assert_nothing_raised() {
+                stopservices
+            }
+            Puppet::Type.allclear
+        }
+    end
+end