puppet 0.24.9 → 0.25.0

data/test/executables/puppetca.rb

@@ -1,115 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppettest'
-require 'mocha'
-
-class TestPuppetCA < Test::Unit::TestCase
-    include PuppetTest::ExeTest
-
-    def setup
-      super
-      Puppet::Util::SUIDManager.stubs(:asuser).yields
-    end
-    
-    def gen_cert(ca, host)
-        runca("-g #{host}")
-        ca.getclientcert(host)[0]
-    end
-    
-    def mkca
-        Puppet::Network::Handler.ca.new()
-    end
-    
-    def mkcert(hostname)
-        cert = nil
-        assert_nothing_raised {
-            cert = Puppet::SSLCertificates::Certificate.new(
-                :name => hostname
-            )
-            cert.mkcsr
-        }
-
-        return cert
-    end
-    
-    def runca(args)
-        debug = ""
-        if Puppet[:debug]
-            debug = "-d "
-        end
-        return %x{puppetca --user=#{Puppet[:user]} #{debug} --group=#{Puppet[:group]} --confdir=#{Puppet[:confdir]} --vardir=#{Puppet[:vardir]} #{args} 2>&1}
-    end
-
-    def test_signing
-        ca = mkca
-        Puppet[:autosign] = false
-        
-        %w{host.test.com Other.Testing.Com}.each do |host|
-            cert = mkcert(host)
-            resp = nil
-            assert_nothing_raised {
-                # We need to use a fake name so it doesn't think the cert is from
-                # itself.  Strangely, getcert stores the csr, because it's a server-side
-                # method, not client.
-                resp = ca.getcert(cert.csr.to_pem, host, "127.0.0.1")
-            }
-            assert_equal(["",""], resp)
-
-            output = nil
-            assert_nothing_raised {
-                output = runca("--list").chomp.split("\n").reject { |line| line =~ /warning:/ } # stupid ssl.rb
-            }
-            assert_equal($?,0)
-            assert_equal([host.downcase], output)
-            assert_nothing_raised {
-                output = runca("--sign -a").chomp.split("\n")
-            }
-
-
-            assert_equal($?,0)
-            assert_equal(["Signed #{host.downcase}"], output)
-
-            
-            signedfile = ca.ca.host2certfile(host)
-            assert(FileTest.exists?(signedfile), "cert does not exist")
-            assert(! FileTest.executable?(signedfile), "cert is executable")
-
-            uid = Puppet::Util.uid(Puppet[:user])
-
-            if Puppet::Util::SUIDManager.uid == 0
-                assert(! FileTest.owned?(signedfile), "cert is owned by root")
-            end
-            assert_nothing_raised {
-                output = runca("--list").chomp.split("\n")
-            }
-            assert_equal($?,0)
-            assert_equal(["No certificates to sign"], output)
-        end
-    end
-    
-    # This method takes a long time to run because of all of the external
-    # executable calls.
-    def test_revocation
-        ca = Puppet::SSLCertificates::CA.new()
-        host1 = gen_cert(ca, "host1.example.com")
-        host2 = gen_cert(ca, "host2.example.com")
-        host3 = gen_cert(ca, "host3.example.com")
-        runca("-r host1.example.com")
-        runca("-r #{host2.serial}")
-        runca("-r 0x#{host3.serial.to_s(16)}")
-        runca("-r 0xff")
-
-        # Recreate CA to force reading of CRL
-        ca = Puppet::SSLCertificates::CA.new()
-        crl = ca.crl
-        revoked = crl.revoked.collect { |r| r.serial }
-        exp = [host1.serial, host2.serial, host3.serial, 255]
-        assert_equal(exp, revoked)
-    end
-    
-    def test_case_insensitive_sign
-    end
-end
-

data/test/executables/puppetd.rb

@@ -1,55 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppet'
-require 'puppet/network/client'
-require 'puppettest'
-require 'socket'
-require 'facter'
-
-class TestPuppetDExe < Test::Unit::TestCase
-    include PuppetTest::ExeTest
-    def setup
-        super
-        Puppet[:certdnsnames] = "localhost"
-        # start the master
-        @manifest = startmasterd
-
-
-        @cmd = "puppetd"
-        @cmd += " --verbose"
-        @cmd += " --test"
-        @cmd += " --masterport %s" % @@port
-        @cmd += " --confdir %s" % Puppet[:confdir]
-        @cmd += " --rundir %s" % File.join(Puppet[:vardir], "run")
-        @cmd += " --vardir %s" % Puppet[:vardir]
-        @cmd += " --server localhost"
-    end
-
-    def test_normalstart
-        # and verify our daemon runs
-        output = nil
-        assert_nothing_raised {
-            output = %x{#{@cmd} 2>&1}
-        }
-        sleep 1
-        assert($? == 0, "Puppetd exited with code %s" % $?)
-
-        assert(FileTest.exists?(@createdfile), "Failed to create file %s" % @createdfile)
-    end
-
-    # now verify that --noop works
-    def test_noop_start
-        @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")
-    end
-end
-

data/test/executables/puppetmasterd.rb

@@ -1,147 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppet'
-require 'puppet/network/client'
-require 'puppettest'
-require 'socket'
-
-class TestPuppetMasterD < Test::Unit::TestCase
-    include PuppetTest::ExeTest
-    def setup
-        super
-        Puppet[:certdnsnames] = "localhost"
-    end
-
-    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[:vardir], "run", "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::Network::Client.status.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 Puppet[:certname]
-        }
-
-        retval = nil
-
-        # init the client certs
-        assert_nothing_raised() {
-            client.cert
-        }
-
-        # 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::Network::Client.master.new(
-                :Server => "localhost",
-                :Port => @@port
-            )
-        }
-        assert_nothing_raised() {
-            retval = client.getconfig
-        }
-
-        objects = nil
-    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|
-            next if line =~ /^puppet/ # skip normal master procs
-            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(exampledir, "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(YAML.dump(facts))
-        assert_nothing_raised() {
-            #Puppet.notice "calling status"
-            #retval = client.call("status.status", "")
-            retval = client.call("puppetmaster.getconfig", textfacts, "yaml")
-        }
-
-        objects = nil
-        assert_nothing_raised {
-            YAML.load(CGI.unescape(retval))
-        }
-        #stopmasterd
-    end
-end
-

data/test/network/client/client.rb

@@ -1,195 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../lib/puppettest'
-
-require 'puppettest'
-require 'mocha'
-require 'puppet/network/client'
-
-class TestClient < Test::Unit::TestCase
-    include PuppetTest::ServerTest
-    class FakeClient < Puppet::Network::Client
-        @drivername = :Test
-    end
-
-    class FakeDriver
-    end
-
-    # a single run through of connect, auth, etc.
-    def disabled_test_sslInitWithAutosigningLocalServer
-        # autosign everything, for simplicity
-        Puppet[:autosign] = true
-
-        # create a server to which to connect
-        mkserver()
-
-        # create our client
-        client = nil
-        assert_nothing_raised {
-            client = Puppet::Network::Client.master.new(
-                :Server => "localhost",
-                :Port => @@port
-            )
-        }
-
-        # get our certs
-        assert_nothing_raised {
-            client.initcerts
-        }
-
-        # make sure all of our cert files exist
-        certfile = File.join(Puppet[:certdir], [client.fqdn, "pem"].join("."))
-        keyfile = File.join(Puppet[:privatekeydir], [client.fqdn, "pem"].join("."))
-        publickeyfile = File.join(Puppet[:publickeydir], [client.fqdn, "pem"].join("."))
-
-        assert(File.exists?(keyfile))
-        assert(File.exists?(certfile))
-        assert(File.exists?(publickeyfile))
-
-        # verify we can retrieve the catalog
-        assert_nothing_raised("Client could not retrieve catalog") {
-            client.getconfig
-        }
-
-        # and apply it
-        assert_nothing_raised("Client could not apply catalog") {
-            client.apply
-        }
-
-        # and verify that it did what it was supposed to
-        assert(FileTest.exists?(@createdfile),
-            "Applied file does not exist")
-    end
-
-
-    # here we create two servers; we 
-    def disabled_test_failureWithUntrustedCerts
-        Puppet[:autosign] = true
-
-        # create a pair of clients with no certs
-        nonemaster = nil
-        assert_nothing_raised {
-            nonemaster = Puppet::Network::Client.master.new(
-                :Server => "localhost",
-                :Port => @@port
-            )
-        }
-
-        nonebucket = nil
-        assert_nothing_raised {
-            nonebucket = Puppet::Network::Client.dipper.new(
-                :Server => "localhost",
-                :Port => @@port
-            )
-        }
-
-        # create a ca so we can create a set of certs
-        # make a new ssldir for it
-        ca = nil
-        assert_nothing_raised {
-            ca = Puppet::Network::Client.ca.new(
-                :CA => true, :Local => true
-            )
-            ca.requestcert
-        }
-
-        # initialize our clients with this set of certs
-        certmaster = nil
-        assert_nothing_raised {
-            certmaster = Puppet::Network::Client.master.new(
-                :Server => "localhost",
-                :Port => @@port
-            )
-        }
-
-        certbucket = nil
-        assert_nothing_raised {
-            certbucket = Puppet::Network::Client.dipper.new(
-                :Server => "localhost",
-                :Port => @@port
-            )
-        }
-
-        # Create a new ssl root.
-        confdir = tempfile()
-        Puppet[:ssldir] = confdir
-        Puppet.settings.mkdir(:ssldir)
-        Puppet.settings.clearused
-        Puppet.settings.use(:ssl, :ca)
-
-        mkserver
-
-        # now verify that our client cannot do non-cert operations
-        # because its certs are signed by a different CA
-        assert_raise(Puppet::Error,
-            "Client was allowed to call getconfig with no certs") {
-            nonemaster.getconfig
-        }
-        assert_raise(Puppet::Error,
-            "Client was allowed to call getconfig with untrusted certs") {
-            certmaster.getconfig
-        }
-
-        assert_raise(Puppet::Network::XMLRPCClientError,
-            "Client was allowed to call backup with no certs") {
-            nonebucket.backup("/etc/passwd")
-        }
-        assert_raise(Puppet::Network::XMLRPCClientError,
-            "Client was allowed to call backup with untrusted certs") {
-            certbucket.backup("/etc/passwd")
-        }
-    end
-
-    def test_client_loading
-        # Make sure we don't get a failure but that we also get nothing back
-        assert_nothing_raised do
-            assert_nil(Puppet::Network::Client.client(:fake),
-                "Got something back from a missing client")
-            assert_nil(Puppet::Network::Client.fake,
-                "Got something back from missing client method")
-        end
-        # Make a fake client
-        dir = tempfile()
-        libdir = File.join([dir, %w{puppet network client}].flatten)
-        FileUtils.mkdir_p(libdir)
-
-        file = File.join(libdir, "faker.rb")
-        File.open(file, "w") do |f|
-            f.puts %{class Puppet::Network::Client
-                class Faker < Client
-                end
-            end
-            }
-        end
-
-        $: << dir
-        cleanup { $:.delete(dir) if $:.include?(dir) }
-
-        client = nil
-        assert_nothing_raised do
-            client = Puppet::Network::Client.client(:faker)
-        end
-        assert(client, "did not load client")
-        assert_nothing_raised do
-            assert_equal(client, Puppet::Network::Client.faker,
-                "Did not get client back from client method")
-        end
-
-        # Now make sure the client behaves correctly
-        assert_equal(:Faker, client.name, "name was not calculated correctly")
-    end
-
-    # Make sure we get a client class for each handler type.
-    def test_loading_all_clients
-        %w{ca dipper file master report resource runner status}.each do |name|
-            client = nil
-            assert_nothing_raised do
-                client = Puppet::Network::Client.client(name)
-            end
-            assert(client, "did not get client for %s" % name)
-            [:name, :handler, :drivername].each do |thing|
-                assert(client.send(thing), "did not get %s for %s" % [thing, name])
-            end
-        end
-    end
-end