puppet 0.18.4 → 0.22.4

data/test/network/server/webrick.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/network/server/webrick'
+
+class TestServer < Test::Unit::TestCase
+    include PuppetTest::ServerTest
+
+    # Make sure we can create a server, and that it knows how to create its
+    # certs by default.
+    def test_basics
+        server = nil
+        assert_raise(Puppet::Error, "server succeeded with no cert") do
+            server = Puppet::Network::Server::WEBrick.new(
+                :Port => @@port,
+                :Handlers => {
+                    :Status => nil
+                }
+            )
+        end
+
+        assert_nothing_raised("Could not create simple server") do
+            server = Puppet::Network::Server::WEBrick.new(
+                :Port => @@port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Status => nil
+                }
+            )
+        end
+
+        assert(server, "did not create server")
+
+        assert(server.cert, "did not retrieve cert")
+    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
+        Puppet[:autosign] = true
+        serverpid, server = mk_status_server
+
+        # create a status client, and verify it can talk
+        client = mk_status_client
+
+        assert(client.cert, "did not get cert for client")
+
+        retval = nil
+        assert_nothing_raised("Could not connect to server") {
+            retval = client.status
+        }
+        assert_equal(1, retval)
+    end
+
+    # Test that a client whose cert has been revoked really can't connect
+    def test_certificate_revocation
+        Puppet[:autosign] = true
+
+        serverpid, server = mk_status_server
+
+        client = mk_status_client
+
+        status = nil
+        assert_nothing_raised() {
+            status = client.status
+        }
+        assert_equal(1, status)
+        client.shutdown
+
+        # Revoke the client's cert
+        ca = Puppet::SSLCertificates::CA.new()
+        ca.revoke(ca.getclientcert(Puppet[:certname])[0].serial)
+
+        # Restart the server
+        @@port += 1
+        Puppet[:autosign] = false
+        kill_and_wait(serverpid, server.pidfile)
+        serverpid, server = mk_status_server
+
+        client = mk_status_client
+        # This time the client should be denied
+        assert_raise(Puppet::Network::XMLRPCClientError) {
+            client.status
+        }
+    end
+    
+    def mk_status_client
+        client = nil
+        # Otherwise, the client initalization will trip over itself
+        # since elements created in the last run are still around
+        Puppet::Type::allclear
+
+        assert_nothing_raised() {
+            client = Puppet::Network::Client.status.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+        }
+        client
+    end
+
+    def mk_status_server
+        server = nil
+        assert_nothing_raised() {
+            server = Puppet::Network::Server::WEBrick.new(
+                :Port => @@port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Status => nil
+                }
+            )
+
+        }
+
+        pid = fork {
+            Puppet[:name] = "puppetmasterd"
+            assert_nothing_raised() {
+                trap(:INT) { server.shutdown }
+                server.start
+            }
+        }
+        @@tmppids << pid
+        [pid, server]
+    end
+
+    def kill_and_wait(pid, file)
+        %x{kill -INT #{pid} 2>/dev/null}
+        count = 0
+        while count < 30 && File::exist?(file)
+            count += 1
+            sleep(1)
+        end
+        assert(count < 30, "Killing server #{pid} failed")
+    end
+end
+
+# $Id: webrick.rb 2259 2007-03-06 19:03:05Z luke $

data/test/network/xmlrpc/client.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/network/xmlrpc/client'
+require 'mocha'
+
+class TestXMLRPCClient < Test::Unit::TestCase
+    def test_set_backtrace
+        error = Puppet::Network::XMLRPCClientError.new("An error")
+        assert_nothing_raised do
+            error.set_backtrace ["caller"]
+        end
+        assert_equal(["caller"], error.backtrace)
+    end
+
+    # Make sure we correctly generate a netclient
+    def test_handler_class
+        # Create a test handler
+        klass = Puppet::Network::XMLRPCClient
+        yay = Class.new(Puppet::Network::Handler) do
+            @interface = XMLRPC::Service::Interface.new("yay") { |iface|
+                iface.add_method("array getcert(csr)")
+            }
+
+            @name = :Yay
+        end
+        Object.const_set("Yay", yay)
+
+        net = nil
+        assert_nothing_raised("Failed when retrieving client for handler") do
+            net = klass.handler_class(yay)
+        end
+
+        assert(net, "did not get net client")
+    end
+
+    # Make sure the xmlrpc client is correctly reading all of the cert stuff
+    # and setting it into the @http var
+    def test_cert_setup
+        client = nil
+        assert_nothing_raised do
+            client = Puppet::Network::XMLRPCClient.new()
+        end
+
+        ca = Puppet::Network::Handler.ca.new
+        caclient = Puppet::Network::Client.ca.new :CA => ca
+        caclient.request_cert
+
+        class << client
+            attr_accessor :http
+        end
+
+        client.http.expects(:ca_file=).with(Puppet[:localcacert])
+        client.http.expects(:cert=).with(caclient.cert)
+        client.http.expects(:key=).with(caclient.key)
+        client.http.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+        client.http.expects(:cert_store=)
+
+        assert_nothing_raised do
+            client.cert_setup(caclient)
+        end
+    end
+end
+
+# $Id: client.rb 2259 2007-03-06 19:03:05Z luke $
+

data/test/network/xmlrpc/processor.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/network/xmlrpc/processor'
+require 'mocha'
+
+class TestXMLRPCProcessor < Test::Unit::TestCase
+    class BaseProcessor
+        def add_handler(interface, handler)
+            @handlers ||= {}
+            @handlers[interface] = handler
+        end
+    end
+
+    # We use a base class just so super() works with add_handler.
+    class Processor < BaseProcessor
+        include Puppet::Network::XMLRPCProcessor
+
+        def set_service_hook(&block)
+            meta_def(:service, &block)
+        end
+    end
+
+    def setup
+        super
+        @processor = Processor.new
+    end
+
+    def test_handlers
+        ca = Puppet::Network::Handler.ca
+        @processor.send(:setup_processor)
+        assert(! @processor.handler_loaded?(:ca), "already have ca handler loaded")
+        assert_nothing_raised do
+            @processor.add_handler(ca.interface, ca.new())
+        end
+
+        assert(@processor.handler_loaded?(:puppetca), "ca handler not loaded by symbol")
+        assert(@processor.handler_loaded?("puppetca"), "ca handler not loaded by string")
+    end
+
+    def test_process
+        ca = Puppet::Network::Handler.ca
+        @processor.send(:setup_processor)
+        assert_nothing_raised do
+            @processor.add_handler(ca.interface, ca.new())
+        end
+
+        fakeparser = Class.new do
+            def parseMethodCall(data)
+                return data
+            end
+        end
+
+        request = Puppet::Network::ClientRequest.new("fake", "192.168.0.1", false)
+        request.handler = "myhandler"
+        request.method = "mymethod"
+
+        @processor.expects(:parser).returns(fakeparser.new)
+
+        request.expects(:handler=).with("myhandler")
+        request.expects(:method=).with("mymethod")
+
+        # I can't get this expectation to take with the argument, for some reason.
+        @processor.expects(:verify)
+        @processor.expects(:handle).with(request.call,
+            "params", request.name, request.ip)
+
+        @processor.send(:process, ["myhandler.mymethod", ["params"]], request)
+    end
+
+    def test_setup_processor
+        @processor.expects(:set_service_hook)
+        @processor.send(:setup_processor)
+    end
+end
+
+# $Id: processor.rb 2259 2007-03-06 19:03:05Z luke $
+

data/test/network/xmlrpc/server.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/network/xmlrpc/server'
+require 'mocha'
+
+class TestXMLRPCServer < Test::Unit::TestCase
+    def setup
+        super
+        assert_nothing_raised do
+            @server = Puppet::Network::XMLRPCServer.new
+        end
+    end
+
+    def test_initialize
+        assert(@server.get_service_hook, "no service hook defined")
+
+        assert_nothing_raised("Did not init @loadedhandlers") do
+            assert(! @server.handler_loaded?(:puppetca),
+                "server thinks handlers are loaded")
+        end
+    end
+end
+
+# $Id: server.rb 2259 2007-03-06 19:03:05Z luke $
+

data/test/network/xmlrpc/webrick_servlet.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/network/xmlrpc/webrick_servlet'
+require 'mocha'
+
+class TestXMLRPCWEBrickServlet < Test::Unit::TestCase
+    def test_basics
+        servlet = nil
+        ca = Puppet::Network::Handler.ca.new
+
+        assert_nothing_raised("Could not create servlet") do
+            servlet = Puppet::Network::XMLRPC::WEBrickServlet.new([ca])
+        end
+
+        assert(servlet.get_service_hook, "service hook was not set up")
+
+        assert(servlet.handler_loaded?(:puppetca),
+            "Did not load handler")
+    end
+end
+
+# $Id: webrick_servlet.rb 2259 2007-03-06 19:03:05Z luke $
+

data/test/other/dsl.rb

@@ -0,0 +1,218 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/dsl'
+require 'puppet/util/autoload'
+require 'puppettest'
+
+class TestDSL < Test::Unit::TestCase
+	include PuppetTest
+	include Puppet::DSL
+
+    def teardown
+        Puppet::Aspect.clear
+    end
+
+    def test_aspect
+        a = nil
+        assert_nothing_raised do
+            a = aspect :yaytest do
+            end
+        end
+
+        assert_equal(a, Puppet::Aspect[:yaytest])
+
+        # Now make a child aspect
+        b = nil
+        assert_nothing_raised do
+            b = aspect :child, :inherits => :yaytest do
+            end
+        end
+
+        assert(b.child_of?(a), "Parentage not set up correctly")
+        assert(b.child_of?(:yaytest), "Parentage not set up for symbols")
+
+        # Now make another subclass
+        c = nil
+        assert_nothing_raised do
+            c = aspect :kid, :inherits => :child do
+            end
+        end
+
+        assert(c.child_of?(b), "Parentage not set up correctly")
+        assert(c.child_of?(a), "Parentage is not inherited")
+
+        # Lastly, make a separate aspect
+        x = nil
+        assert_nothing_raised do
+            x = aspect :other do
+            end
+        end
+
+        assert(! x.child_of?(a), "Parentage came from nowhere")
+        assert(! x.child_of?(b), "Parentage came from nowhere")
+        assert(! x.child_of?(c), "Parentage came from nowhere")
+
+        # Make sure we can specify the name or the aspect
+        y = nil
+        assert_nothing_raised do
+            x = aspect :naming, :inherits => a do
+            end
+        end
+        assert(x.child_of?(a), "Parentage not set up correctly")
+
+        # And make sure the parent must exist
+        z = nil
+        assert_raise(RuntimeError) do
+            z = aspect :noparent, :inherits => :nosuchaspect do
+            end
+        end
+        assert(x.child_of?(a), "Parentage not set up correctly")
+    end
+
+    def test_evaluate
+        parent = child = nil
+        parenteval = childeval = nil
+        
+        assert_nothing_raised do
+            parent = aspect :parent do
+                if parenteval
+                    raise "parent already evaluated"
+                end
+                parenteval = true
+            end
+
+            child = aspect :child, :inherits => parent do
+                if childeval
+                    raise "child already evaluated"
+                end
+                childeval = true
+            end
+        end
+
+        assert_nothing_raised do
+            parent.evaluate()
+        end
+
+        assert(parenteval, "Parent was not evaluated")
+        assert(parent.evaluated?, "parent was not considered evaluated")
+
+        # Make sure evaluating twice silently does nothing
+        assert_nothing_raised do
+            parent.evaluate()
+        end
+
+        # Now evaluate the child
+        assert_nothing_raised do
+            child.evaluate
+        end
+
+        assert(childeval, "child was not evaluated")
+        assert(child.evaluated?, "child was not considered evaluated")
+
+        # Now reset them both
+        parenteval = childeval = nil
+        parent.evaluated = false
+        child.evaluated = false
+
+        # evaluate the child
+        assert_nothing_raised do
+            child.evaluate
+        end
+
+        # and make sure both get evaluated
+        assert(parenteval, "Parent was not evaluated")
+        assert(parent.evaluated?, "parent was not considered evaluated")
+        assert(childeval, "child was not evaluated")
+        assert(child.evaluated?, "child was not considered evaluated")
+    end
+
+    def test_acquire
+        evalled = false
+        a = aspect :test do
+            evalled = true
+        end
+
+        assert_nothing_raised do
+            acquire :test
+        end
+
+        assert(evalled, "Did not evaluate aspect")
+
+        assert_nothing_raised do
+            acquire :test
+        end
+    end
+
+    def test_newresource
+        filetype = Puppet::Type.type(:file)
+        path = tempfile()
+
+        a = aspect :testing
+
+        resource = nil
+        assert_nothing_raised do
+            resource = a.newresource filetype, path,
+                :content => "yay", :mode => "640"
+        end
+
+        assert_instance_of(Puppet::Parser::Resource, resource)
+
+        assert_equal("yay", resource[:content])
+        assert_equal("640", resource[:mode])
+        assert_equal(:testing, resource.source.name)
+
+        # Now try exporting our aspect
+        assert_nothing_raised do
+            a.evaluate
+        end
+
+        result = nil
+        assert_nothing_raised do
+            result = a.export
+        end
+
+        assert_equal([resource], result)
+
+        # Then try the DSL export
+        assert_nothing_raised do
+            result = export
+        end
+
+        assert_instance_of(Puppet::TransBucket, result)
+
+        # And just for kicks, test applying everything
+        assert_nothing_raised do
+            apply()
+        end
+
+        assert(FileTest.exists?(path), "File did not get created")
+        assert_equal("yay", File.read(path))
+    end
+
+    def test_typemethods
+        Puppet::Type.loadall
+        filetype = Puppet::Type.type(:file)
+        path = tempfile()
+
+        a = aspect :testing
+
+        Puppet::Type.eachtype do |type|
+            next if type.name.to_s =~ /test/
+            assert(a.respond_to?(type.name),
+                "Aspects do not have a %s method" % type.name)
+        end
+
+        file = nil
+        assert_nothing_raised do
+            file = a.file path,
+                :content => "yay", :mode => "640"
+        end
+
+        assert_instance_of(Puppet::Parser::Resource, file)
+    end
+end
+
+# $Id: dsl.rb 2178 2007-02-07 23:56:59Z luke $