puppet 0.25.5 → 2.6.0

data/spec/unit/network/http/rack/xmlrpc_spec.rb

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+require 'puppet/network/http/rack' if Puppet.features.rack?
+require 'puppet/network/http/rack/xmlrpc' if Puppet.features.rack?
+
+describe "Puppet::Network::HTTP::RackXMLRPC" do
+  confine "Rack is not available" => Puppet.features.rack?
+
+  describe "when initializing" do
+    it "should create an Puppet::Network::XMLRPCServer" do
+      Puppet::Network::XMLRPCServer.expects(:new).returns stub_everything
+      Puppet::Network::HTTP::RackXMLRPC.new([])
+    end
+
+    it "should create each handler" do
+      handler = stub_everything 'handler'
+      Puppet::Network::XMLRPCServer.any_instance.stubs(:add_handler)
+      Puppet::Network::Handler.expects(:handler).returns(handler).times(2)
+      Puppet::Network::HTTP::RackXMLRPC.new([:foo, :bar])
+    end
+
+    it "should add each handler to the XMLRPCserver" do
+      handler = stub_everything 'handler'
+      Puppet::Network::Handler.stubs(:handler).returns(handler)
+      Puppet::Network::XMLRPCServer.any_instance.expects(:add_handler).times(2)
+      Puppet::Network::HTTP::RackXMLRPC.new([:foo, :bar])
+    end
+  end
+
+  describe "when serving a request" do
+
+    before :each do
+      foo_handler = stub_everything 'foo_handler'
+      Puppet::Network::Handler.stubs(:handler).with(:foo).returns foo_handler
+      Puppet::Network::XMLRPCServer.any_instance.stubs(:add_handler)
+      Puppet::Network::XMLRPCServer.any_instance.stubs(:process).returns('<xml/>')
+      @handler = Puppet::Network::HTTP::RackXMLRPC.new([:foo])
+    end
+
+    before :each do
+      @response = Rack::Response.new
+    end
+
+    def mk_req(opts = {})
+      opts[:method] = 'POST' if !opts[:method]
+      opts['CONTENT_TYPE'] = 'text/xml; foo=bar' if !opts['CONTENT_TYPE']
+      env = Rack::MockRequest.env_for('/RPC2', opts)
+      Rack::Request.new(env)
+    end
+
+    it "should reject non-POST requests" do
+      req = mk_req :method => 'PUT'
+      @handler.process(req, @response)
+      @response.status.should == 405
+    end
+
+    it "should reject non text/xml requests" do
+      req = mk_req 'CONTENT_TYPE' => 'yadda/plain'
+    end
+
+    it "should create a ClientRequest" do
+      cr = Puppet::Network::ClientRequest.new(nil, '127.0.0.1', false)
+      Puppet::Network::ClientRequest.expects(:new).returns cr
+      req = mk_req
+      @handler.process(req, @response)
+    end
+
+    it "should let xmlrpcserver process the request" do
+      Puppet::Network::XMLRPCServer.any_instance.expects(:process).returns('yay')
+      req = mk_req
+      @handler.process(req, @response)
+    end
+
+    it "should report the response as OK" do
+      req = mk_req
+      @handler.process(req, @response)
+      @response.status.should == 200
+    end
+
+    it "should report the response with the correct content type" do
+      req = mk_req
+      @handler.process(req, @response)
+      @response['Content-Type'].should == 'text/xml; charset=utf-8'
+    end
+
+    it "should set 'authenticated' to false if no certificate is present" do
+      req = mk_req
+      Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == false }
+      @handler.process(req, @response)
+    end
+
+    it "should use the client's ip address" do
+      req = mk_req 'REMOTE_ADDR' => 'ipaddress'
+      Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| ip == 'ipaddress' }
+      @handler.process(req, @response)
+    end
+
+    describe "with pre-validated certificates" do
+
+      it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
+        Puppet.settings.stubs(:value).returns "eh"
+        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        req = mk_req "myheader" => "/CN=host.domain.com"
+        @handler.process(req, @response)
+      end
+
+      it "should retrieve the hostname by matching the certificate parameter" do
+        Puppet.settings.stubs(:value).returns "eh"
+        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| node == "host.domain.com" }
+        req = mk_req "myheader" => "/CN=host.domain.com"
+        @handler.process(req, @response)
+      end
+
+      it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
+        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
+        req = mk_req "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com"
+        @handler.process(req, @response)
+      end
+
+      it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
+        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == true }
+        req = mk_req "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com"
+        @handler.process(req, @response)
+      end
+
+      it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
+        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == false }
+        req = mk_req "myheader" => "whatever", "certheader" => "/CN=host.domain.com"
+        @handler.process(req, @response)
+      end
+
+      it "should consider the host unauthenticated if no certificate information is present" do
+        Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
+        Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
+        Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == false }
+        req = mk_req "myheader" => nil, "certheader" => "/CN=host.domain.com"
+        @handler.process(req, @response)
+      end
+
+      it "should resolve the node name with an ip address look-up if no certificate is present" do
+        Puppet.settings.stubs(:value).returns "eh"
+        Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
+        Resolv.any_instance.expects(:getname).returns("host.domain.com")
+        Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| node == "host.domain.com" }
+        req = mk_req "myheader" => nil
+        @handler.process(req, @response)
+      end
+    end
+  end
+end

data/spec/unit/network/http/rack_spec.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/network/http/rack' if Puppet.features.rack?
+
+describe "Puppet::Network::HTTP::Rack" do
+  confine "Rack is not available" => Puppet.features.rack?
+
+  describe "while initializing" do
+
+    it "should require a protocol specification" do
+      Proc.new { Puppet::Network::HTTP::Rack.new({}) }.should raise_error(ArgumentError)
+    end
+
+    it "should not accept imaginary protocols" do
+      Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:foo]}) }.should raise_error(ArgumentError)
+    end
+
+    it "should accept the REST protocol" do
+      Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:rest]}) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should create a RackREST instance" do
+      Puppet::Network::HTTP::RackREST.expects(:new)
+      Puppet::Network::HTTP::Rack.new({:protocols => [:rest]})
+    end
+
+    describe "with XMLRPC enabled" do
+
+      it "should require XMLRPC handlers" do
+        Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:xmlrpc]}) }.should raise_error(ArgumentError)
+      end
+
+      it "should create a RackXMLRPC instance" do
+        Puppet::Network::HTTP::RackXMLRPC.expects(:new)
+        Puppet::Network::HTTP::Rack.new({:protocols => [:xmlrpc], :xmlrpc_handlers => [:Status]})
+      end
+
+    end
+
+  end
+
+  describe "when called" do
+
+    before :all do
+      @app = Puppet::Network::HTTP::Rack.new({:protocols => [:rest]})
+      # let's use Rack::Lint to verify that we're OK with the rack specification
+      @linted = Rack::Lint.new(@app)
+    end
+
+    before :each do
+      @env = Rack::MockRequest.env_for('/')
+    end
+
+    it "should create a Request object" do
+      request = Rack::Request.new(@env)
+      Rack::Request.expects(:new).returns request
+      @linted.call(@env)
+    end
+
+    it "should create a Response object" do
+      Rack::Response.expects(:new).returns stub_everything
+      @app.call(@env) # can't lint when Rack::Response is a stub
+    end
+
+    it "should let RackREST process the request" do
+      Puppet::Network::HTTP::RackREST.any_instance.expects(:process).once
+      @linted.call(@env)
+    end
+
+    it "should catch unhandled exceptions from RackREST" do
+      Puppet::Network::HTTP::RackREST.any_instance.expects(:process).raises(ArgumentError, 'test error')
+      Proc.new { @linted.call(@env) }.should_not raise_error
+    end
+
+    it "should finish() the Response" do
+      Rack::Response.any_instance.expects(:finish).once
+      @app.call(@env) # can't lint when finish is a stub
+    end
+
+  end
+
+  describe "when serving XMLRPC" do
+
+    before :all do
+      @app = Puppet::Network::HTTP::Rack.new({:protocols => [:rest, :xmlrpc], :xmlrpc_handlers => [:Status]})
+      @linted = Rack::Lint.new(@app)
+    end
+
+    before :each do
+      @env = Rack::MockRequest.env_for('/RPC2', :method => 'POST')
+    end
+
+    it "should use RackXMLRPC to serve /RPC2 requests" do
+      Puppet::Network::HTTP::RackXMLRPC.any_instance.expects(:process).once
+      @linted.call(@env)
+    end
+
+  end
+
+end
+

data/spec/unit/network/http/webrick/rest_spec.rb

@@ -0,0 +1,180 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+require 'puppet/network/http'
+require 'puppet/network/http/webrick/rest'
+
+describe Puppet::Network::HTTP::WEBrickREST do
+  it "should include the Puppet::Network::HTTP::Handler module" do
+    Puppet::Network::HTTP::WEBrickREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
+  end
+
+  describe "when initializing" do
+    it "should call the Handler's initialization hook with its provided arguments as the server and handler" do
+      Puppet::Network::HTTP::WEBrickREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
+      Puppet::Network::HTTP::WEBrickREST.new("my", "arguments")
+    end
+  end
+
+  describe "when receiving a request" do
+    before do
+      @request     = stub('webrick http request', :query => {}, :peeraddr => %w{eh boo host ip}, :client_cert => nil)
+      @response    = stub('webrick http response', :status= => true, :body= => true)
+      @model_class = stub('indirected model class')
+      @webrick     = stub('webrick http server', :mount => true, :[] => {})
+      Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
+      @handler = Puppet::Network::HTTP::WEBrickREST.new(@webrick, :foo)
+    end
+
+    it "should delegate its :service method to its :process method" do
+      @handler.expects(:process).with(@request, @response).returns "stuff"
+      @handler.service(@request, @response).should == "stuff"
+    end
+
+    describe "when using the Handler interface" do
+      it "should use the 'accept' request parameter as the Accept header" do
+        @request.expects(:[]).with("accept").returns "foobar"
+        @handler.accept_header(@request).should == "foobar"
+      end
+
+      it "should use the 'content-type' request header as the Content-Type header" do
+        @request.expects(:[]).with("content-type").returns "foobar"
+        @handler.content_type_header(@request).should == "foobar"
+      end
+
+      it "should use the request method as the http method" do
+        @request.expects(:request_method).returns "FOO"
+        @handler.http_method(@request).should == "FOO"
+      end
+
+      it "should return the request path as the path" do
+        @request.expects(:path).returns "/foo/bar"
+        @handler.path(@request).should == "/foo/bar"
+      end
+
+      it "should return the request body as the body" do
+        @request.expects(:body).returns "my body"
+        @handler.body(@request).should == "my body"
+      end
+
+      it "should set the response's 'content-type' header when setting the content type" do
+        @response.expects(:[]=).with("content-type", "text/html")
+        @handler.set_content_type(@response, "text/html")
+      end
+
+      it "should set the status and body on the response when setting the response for a successful query" do
+        @response.expects(:status=).with 200
+        @response.expects(:body=).with "mybody"
+
+        @handler.set_response(@response, "mybody", 200)
+      end
+
+      describe "when the result is a File" do
+        before(:each) do
+          stat = stub 'stat', :size => 100
+          @file = stub 'file', :stat => stat, :path => "/tmp/path"
+          @file.stubs(:is_a?).with(File).returns(true)
+        end
+
+        it "should serve it" do
+          @response.stubs(:[]=)
+
+          @response.expects(:status=).with 200
+          @response.expects(:body=).with @file
+
+          @handler.set_response(@response, @file, 200)
+        end
+
+        it "should set the Content-Length header" do
+          @response.expects(:[]=).with('content-length', 100)
+
+          @handler.set_response(@response, @file, 200)
+        end
+      end
+
+      it "should set the status and message on the response when setting the response for a failed query" do
+        @response.expects(:status=).with 400
+        @response.expects(:reason_phrase=).with "mybody"
+
+        @handler.set_response(@response, "mybody", 400)
+      end
+    end
+
+    describe "and determining the request parameters" do
+      it "should include the HTTP request parameters, with the keys as symbols" do
+        @request.stubs(:query).returns("foo" => "baz", "bar" => "xyzzy")
+        result = @handler.params(@request)
+        result[:foo].should == "baz"
+        result[:bar].should == "xyzzy"
+      end
+
+      it "should CGI-decode the HTTP parameters" do
+        encoding = CGI.escape("foo bar")
+        @request.expects(:query).returns('foo' => encoding)
+        result = @handler.params(@request)
+        result[:foo].should == "foo bar"
+      end
+
+      it "should convert the string 'true' to the boolean" do
+        @request.expects(:query).returns('foo' => "true")
+        result = @handler.params(@request)
+        result[:foo].should be_true
+      end
+
+      it "should convert the string 'false' to the boolean" do
+        @request.expects(:query).returns('foo' => "false")
+        result = @handler.params(@request)
+        result[:foo].should be_false
+      end
+
+      it "should YAML-load and CGI-decode values that are YAML-encoded" do
+        escaping = CGI.escape(YAML.dump(%w{one two}))
+        @request.expects(:query).returns('foo' => escaping)
+        result = @handler.params(@request)
+        result[:foo].should == %w{one two}
+      end
+
+      it "should not allow clients to set the node via the request parameters" do
+        @request.stubs(:query).returns("node" => "foo")
+        @handler.stubs(:resolve_node)
+
+        @handler.params(@request)[:node].should be_nil
+      end
+
+      it "should not allow clients to set the IP via the request parameters" do
+        @request.stubs(:query).returns("ip" => "foo")
+        @handler.params(@request)[:ip].should_not == "foo"
+      end
+
+      it "should pass the client's ip address to model find" do
+        @request.stubs(:peeraddr).returns(%w{noidea dunno hostname ipaddress})
+        @handler.params(@request)[:ip].should == "ipaddress"
+      end
+
+      it "should set 'authenticated' to true if a certificate is present" do
+        cert = stub 'cert', :subject => [%w{CN host.domain.com}]
+        @request.stubs(:client_cert).returns cert
+        @handler.params(@request)[:authenticated].should be_true
+      end
+
+      it "should set 'authenticated' to false if no certificate is present" do
+        @request.stubs(:client_cert).returns nil
+        @handler.params(@request)[:authenticated].should be_false
+      end
+
+      it "should pass the client's certificate name to model method if a certificate is present" do
+        cert = stub 'cert', :subject => [%w{CN host.domain.com}]
+        @request.stubs(:client_cert).returns cert
+        @handler.params(@request)[:node].should == "host.domain.com"
+      end
+
+      it "should resolve the node name with an ip address look-up if no certificate is present" do
+        @request.stubs(:client_cert).returns nil
+
+        @handler.expects(:resolve_node).returns(:resolved_node)
+
+        @handler.params(@request)[:node].should == :resolved_node
+      end
+    end
+  end
+end

data/spec/unit/network/http/webrick_spec.rb

@@ -0,0 +1,339 @@
+#!/usr/bin/env ruby
+#
+#  Created by Rick Bradley on 2007-10-15.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/network/http'
+require 'puppet/network/http/webrick'
+
+describe Puppet::Network::HTTP::WEBrick, "after initializing" do
+  it "should not be listening" do
+    Puppet::Network::HTTP::WEBrick.new.should_not be_listening
+  end
+end
+
+describe Puppet::Network::HTTP::WEBrick, "when turning on listening" do
+  before do
+    @mock_webrick = stub('webrick', :[] => {}, :listeners => [], :status => :Running)
+    [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
+    WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
+    @server = Puppet::Network::HTTP::WEBrick.new
+    [:setup_logger, :setup_ssl].each {|meth| @server.stubs(meth).returns({})} # the empty hash is required because of how we're merging
+    @listen_params = { :address => "127.0.0.1", :port => 31337, :xmlrpc_handlers => [], :protocols => [ :rest ] }
+  end
+
+  it "should fail if already listening" do
+    @server.listen(@listen_params)
+    Proc.new { @server.listen(@listen_params) }.should raise_error(RuntimeError)
+  end
+
+  it "should require at least one protocol" do
+    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :protocols == k}) }.should raise_error(ArgumentError)
+  end
+
+  it "should require a listening address to be specified" do
+    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :address == k})}.should raise_error(ArgumentError)
+  end
+
+  it "should require a listening port to be specified" do
+    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :port == k})}.should raise_error(ArgumentError)
+  end
+
+  it "should order a webrick server to start in a separate thread" do
+    @mock_webrick.expects(:start)
+    # If you remove this you'll sometimes get race condition problems
+    Thread.expects(:new).yields
+    @server.listen(@listen_params)
+  end
+
+  it "should tell webrick to listen on the specified address and port" do
+    WEBrick::HTTPServer.expects(:new).with {|args|
+      args[:Port] == 31337 and args[:BindAddress] == "127.0.0.1"
+    }.returns(@mock_webrick)
+    @server.listen(@listen_params)
+  end
+
+  it "should configure a logger for webrick" do
+    @server.expects(:setup_logger).returns(:Logger => :mylogger)
+
+    WEBrick::HTTPServer.expects(:new).with {|args|
+      args[:Logger] == :mylogger
+    }.returns(@mock_webrick)
+
+    @server.listen(@listen_params)
+  end
+
+  it "should configure SSL for webrick" do
+    @server.expects(:setup_ssl).returns(:Ssl => :testing, :Other => :yay)
+
+    WEBrick::HTTPServer.expects(:new).with {|args|
+      args[:Ssl] == :testing and args[:Other] == :yay
+    }.returns(@mock_webrick)
+
+    @server.listen(@listen_params)
+  end
+
+  it "should be listening" do
+    @server.listen(@listen_params)
+    @server.should be_listening
+  end
+
+  describe "when the REST protocol is requested" do
+    it "should register the REST handler at /" do
+      # We don't care about the options here.
+      @mock_webrick.expects(:mount).with { |path, klass, options| path == "/" and klass == Puppet::Network::HTTP::WEBrickREST }
+
+      @server.listen(@listen_params.merge(:protocols => [:rest]))
+    end
+  end
+
+  describe "when the XMLRPC protocol is requested" do
+    before do
+      @servlet = mock 'servlet'
+
+      Puppet::Network::XMLRPC::WEBrickServlet.stubs(:new).returns @servlet
+
+      @master_handler = mock('master_handler')
+      @file_handler = mock('file_handler')
+
+      @master = mock 'master'
+      @file = mock 'file'
+      @master_handler.stubs(:new).returns @master
+      @file_handler.stubs(:new).returns @file
+
+      Puppet::Network::Handler.stubs(:handler).with(:master).returns @master_handler
+      Puppet::Network::Handler.stubs(:handler).with(:fileserver).returns @file_handler
+    end
+
+    it "should do nothing if no xmlrpc handlers have been specified" do
+      Puppet::Network::Handler.expects(:handler).never
+
+      @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => []))
+    end
+
+    it "should look the handler classes up via their base class" do
+      Puppet::Network::Handler.expects(:handler).with(:master).returns @master_handler
+      Puppet::Network::Handler.expects(:handler).with(:fileserver).returns @file_handler
+
+      @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
+    end
+
+    it "should create an instance for each requested xmlrpc handler" do
+      @master_handler.expects(:new).returns @master
+      @file_handler.expects(:new).returns @file
+
+      @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
+    end
+
+    it "should create a webrick servlet with the xmlrpc handler instances" do
+      Puppet::Network::XMLRPC::WEBrickServlet.expects(:new).with([@master, @file]).returns @servlet
+
+      @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
+    end
+
+    it "should mount the webrick servlet at /RPC2" do
+      @mock_webrick.stubs(:mount)
+      @mock_webrick.expects(:mount).with("/RPC2", @servlet)
+
+      @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
+    end
+  end
+end
+
+
+describe Puppet::Network::HTTP::WEBrick, "when looking up the class to handle a protocol" do
+  it "should require a protocol" do
+    lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol }.should raise_error(ArgumentError)
+  end
+
+  it "should accept a protocol" do
+    lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol("bob") }.should_not raise_error(ArgumentError)
+  end
+
+  it "should use a WEBrick + REST class when a REST protocol is specified" do
+    Puppet::Network::HTTP::WEBrick.class_for_protocol("rest").should == Puppet::Network::HTTP::WEBrickREST
+  end
+
+  it "should fail when an unknown protocol is specified" do
+    lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol("abcdefg") }.should raise_error
+  end
+end
+
+describe Puppet::Network::HTTP::WEBrick, "when turning off listening" do
+  before do
+    @mock_webrick = stub('webrick', :[] => {}, :listeners => [], :status => :Running)
+    [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
+    WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
+    @server = Puppet::Network::HTTP::WEBrick.new
+    [:setup_logger, :setup_ssl].each {|meth| @server.stubs(meth).returns({})} # the empty hash is required because of how we're merging
+    @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest ] }
+  end
+
+  it "should fail unless listening" do
+    Proc.new { @server.unlisten }.should raise_error(RuntimeError)
+  end
+
+  it "should order webrick server to stop" do
+    @mock_webrick.expects(:shutdown)
+    @server.listen(@listen_params)
+    @server.unlisten
+  end
+
+  it "should no longer be listening" do
+    @server.listen(@listen_params)
+    @server.unlisten
+    @server.should_not be_listening
+  end
+end
+
+describe Puppet::Network::HTTP::WEBrick do
+  before do
+    @mock_webrick = stub('webrick', :[] => {})
+    [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
+    WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
+    @server = Puppet::Network::HTTP::WEBrick.new
+  end
+
+  describe "when configuring an http logger" do
+    before do
+      Puppet.settings.stubs(:value).returns "something"
+      Puppet.settings.stubs(:use)
+      @filehandle = stub 'handle', :fcntl => nil, :sync => nil
+
+      File.stubs(:open).returns @filehandle
+    end
+
+    it "should use the settings for :main, :ssl, and the process name" do
+      Puppet.settings.stubs(:value).with(:name).returns "myname"
+      Puppet.settings.expects(:use).with(:main, :ssl, "myname")
+
+      @server.setup_logger
+    end
+
+    it "should use the masterlog if the run_mode is master" do
+      Puppet.run_mode.stubs(:master?).returns(true)
+      Puppet.settings.expects(:value).with(:masterhttplog).returns "/master/log"
+
+      File.expects(:open).with("/master/log", "a+").returns @filehandle
+
+      @server.setup_logger
+    end
+
+    it "should use the httplog if the run_mode is not master" do
+      Puppet.run_mode.stubs(:master?).returns(false)
+      Puppet.settings.expects(:value).with(:httplog).returns "/other/log"
+
+      File.expects(:open).with("/other/log", "a+").returns @filehandle
+
+      @server.setup_logger
+    end
+
+    describe "and creating the logging filehandle" do
+      it "should set fcntl to 'Fcntl::F_SETFD, Fcntl::FD_CLOEXEC'" do
+        @filehandle.expects(:fcntl).with(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+        @server.setup_logger
+      end
+
+      it "should sync the filehandle" do
+        @filehandle.expects(:sync)
+
+        @server.setup_logger
+      end
+    end
+
+    it "should create a new WEBrick::Log instance with the open filehandle" do
+      WEBrick::Log.expects(:new).with(@filehandle)
+
+      @server.setup_logger
+    end
+
+    it "should set debugging if the current loglevel is :debug" do
+      Puppet::Util::Log.expects(:level).returns :debug
+
+      WEBrick::Log.expects(:new).with { |handle, debug| debug == WEBrick::Log::DEBUG }
+
+      @server.setup_logger
+    end
+
+    it "should return the logger as the main log" do
+      logger = mock 'logger'
+      WEBrick::Log.expects(:new).returns logger
+
+      @server.setup_logger[:Logger].should == logger
+    end
+
+    it "should return the logger as the access log using both the Common and Referer log format" do
+      logger = mock 'logger'
+      WEBrick::Log.expects(:new).returns logger
+
+      @server.setup_logger[:AccessLog].should == [
+        [logger, WEBrick::AccessLog::COMMON_LOG_FORMAT],
+        [logger, WEBrick::AccessLog::REFERER_LOG_FORMAT]
+      ]
+    end
+  end
+
+  describe "when configuring ssl" do
+    before do
+      @key = stub 'key', :content => "mykey"
+      @cert = stub 'cert', :content => "mycert"
+      @host = stub 'host', :key => @key, :certificate => @cert, :name => "yay", :ssl_store => "mystore"
+
+      Puppet::SSL::Certificate.stubs(:find).with('ca').returns @cert
+
+      Puppet::SSL::Host.stubs(:localhost).returns @host
+    end
+
+    it "should use the key from the localhost SSL::Host instance" do
+      Puppet::SSL::Host.expects(:localhost).returns @host
+      @host.expects(:key).returns @key
+
+      @server.setup_ssl[:SSLPrivateKey].should == "mykey"
+    end
+
+    it "should configure the certificate" do
+      @server.setup_ssl[:SSLCertificate].should == "mycert"
+    end
+
+    it "should fail if no CA certificate can be found" do
+      Puppet::SSL::Certificate.stubs(:find).with('ca').returns nil
+
+      lambda { @server.setup_ssl }.should raise_error(Puppet::Error)
+    end
+
+    it "should specify the path to the CA certificate" do
+      Puppet.settings.stubs(:value).returns "whatever"
+      Puppet.settings.stubs(:value).with(:hostcrl).returns 'false'
+      Puppet.settings.stubs(:value).with(:localcacert).returns '/ca/crt'
+
+      @server.setup_ssl[:SSLCACertificateFile].should == "/ca/crt"
+    end
+
+    it "should start ssl immediately" do
+      @server.setup_ssl[:SSLStartImmediately].should be_true
+    end
+
+    it "should enable ssl" do
+      @server.setup_ssl[:SSLEnable].should be_true
+    end
+
+    it "should configure the verification method as 'OpenSSL::SSL::VERIFY_PEER'" do
+      @server.setup_ssl[:SSLVerifyClient].should == OpenSSL::SSL::VERIFY_PEER
+    end
+
+    it "should add an x509 store" do
+      Puppet.settings.stubs(:value).returns "whatever"
+      Puppet.settings.stubs(:value).with(:hostcrl).returns '/my/crl'
+
+      @host.expects(:ssl_store).returns "mystore"
+
+      @server.setup_ssl[:SSLCertificateStore].should == "mystore"
+    end
+
+    it "should set the certificate name to 'nil'" do
+      @server.setup_ssl[:SSLCertName].should be_nil
+    end
+  end
+end